OpenGL update parts of VBO (point cloud) - c++

Question

I have a udp client for reading points from a server that generates points in 4 msec and each packet have near 3000 points. i read this points and map them to a matrix with 1 million elements of coordinates. (i create a hash table from streamed points with fixed keys. i mean you can think of a 1000 keys and each key has maximum 1000 points but its varying. after completing this table any new value i get from server, map to my keys in a sorted manner, i mean, i updated points in smaller keys first and ... :D
i really shamed i cant do this, my LCD with 1990x1080 pixels do this so faster than me!! :-((
i want to insert this to a VBO and then upgrading each key parts in 30 ms.
so i want to create 1000 vbos for drawing and 1000 vbos for buffering and after each 33 ms iteration i change 50 vbos of drawing ones with buffering ones. each vbo has maximum 0f 1000 points and colors, and number of points in one VBO change from 10 to 1000;
my problem start here i don't understand how VBO's work and best solution for implementation of this problem? :D
1- my first question: why i create a VAO and how its associated to new gen buffers?
its look like its associated to exactly next glGenBuffer() right? but in any sample i read i don't see any using of this pointer (just use for draw)? this is my code for creating a vbo i downloaded from somewhere
glGenVertexArrays(1, &vertexArrayObject);
glBindVertexArray(vertexArrayObject);
// First see if the vertex array buffer has been created...
if(uiVertexArray == 0) { // Nope, we need to create it
glGenBuffers(1, &uiVertexArray);
glBindBuffer(GL_ARRAY_BUFFER, uiVertexArray);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * nNumVerts, NULL, GL_DYNAMIC_DRAW);
}
// Now see if it's already mapped, if not, map it
if(pVerts == NULL) {
glBindBuffer(GL_ARRAY_BUFFER, uiVertexArray);
pVerts = (M3DVector3f *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
}
// Ignore if we go past the end, keeps things from blowing up
if(nVertsBuilding >= nNumVerts)
return;
// Copy it in...
pVerts[nVertsBuilding][0] = x;
pVerts[nVertsBuilding][1] = y;
pVerts[nVertsBuilding][2] = z;
nVertsBuilding++;
for color and texture mapping its look like. which has better performance (GL_DYNAMIC_DRAW, GL_STREAM_DRAW)
2- this is a draw function? why use last line? for creating the next VBO and VAO?
// Set up the vertex array object
glBindVertexArray(vertexArrayObject);
glDrawArrays(primitiveType, 0, nNumVerts);
glBindVertexArray(0);
3- in the next time i want change a buffered VBO contents with new points i must do this all again for different number of points and if i do this i must delete last buffer of VBO or not?
// Vertex buffer objects
if(uiVertexArray != 0)
glDeleteBuffers(1, &uiVertexArray);
4- can i resize my VBOs and don't use recreate buffer VBO's?
5- How to copy data from buffer VBO's to draw VBO's?
this is my swap buffers with draw VBO's in main draw function, i recreate VBO data from first in swap function
for(int i=0; i<1000; i++)
if(must_show_buffer(i))
{
bufferVBO[i].draw();
drawedVBO[i].swap(bufferVBO[i]);
}
else drawedVBO[i].draw();
UPDATE:
i use this functions for swap data:
if(batch->cVerts != NULL)
{
CopyVertexData3f(batch->cVerts);
CopyColorData4f(batch->cColors);
}
End();
void GLBatch::CopyColorData4f(M3DVector4f *vColors)
{
// First time, create the buffer object, allocate the space
if(uiColorArray == 0) {
glGenBuffers(1, &uiColorArray);
glBindBuffer(GL_ARRAY_BUFFER, uiColorArray);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 4 * nNumVerts, vColors, GL_DYNAMIC_DRAW);
}
else { // Just bind to existing object
glBindBuffer(GL_ARRAY_BUFFER, uiColorArray);
// Copy the data in
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * 4 * nNumVerts, vColors);
pColors = NULL;
}
}
this approach is work correct but glBufferSubData increase memory usage so fast and i get a memory out exception
and this approach
if(batch->uiVertexArray != NULL)
{
// First time, create the buffer object, allocate the space
if(uiVertexArray == 0) {
glGenBuffers(1, &uiVertexArray);
glBindBuffer(GL_ARRAY_BUFFER, uiVertexArray);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * nNumVerts, NULL, GL_DYNAMIC_DRAW);
}
// Fast copy data
glBindBuffer(GL_COPY_READ_BUFFER, batch->uiVertexArray);
glBindBuffer(GL_COPY_WRITE_BUFFER, uiVertexArray);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, nNumVerts);
glBindBuffer(GL_COPY_READ_BUFFER, 0);
glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
//copy color data
if(uiColorArray == 0) {
glGenBuffers(1, &uiColorArray);
glBindBuffer(GL_ARRAY_BUFFER, uiColorArray);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 4 * nNumVerts, NULL, GL_DYNAMIC_DRAW);
}
glBindBuffer(GL_COPY_READ_BUFFER, batch->uiColorArray);
glBindBuffer(GL_COPY_WRITE_BUFFER, uiColorArray);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, nNumVerts);
glBindBuffer(GL_COPY_READ_BUFFER, 0);
glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
}
without memory allocation problem but doesn't clear before points
what i miss in each implementation?

Answer 1

VBOs are associated to the currently bound VAO during glVertexAttribPointer
unbinding buffers is a good practice, remember that bind state is global and the less global state you rely on the better
no need to delete the VBO you can just skip the glGenBuffers(1, &uiVertexArray); call
yes a new call to glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * nNumVerts, NULL, GL_DYNAMIC_DRAW); with the new nNumVerts will resize the buffer (and thrash any existing data)
you can do the following:
glBindBuffer(GL_COPY_READ_BUFFER, bufferVBO);
glBindBuffer(GL_COPY_WRITE_BUFFER, drawVBO);
glCopyBufferSubData(GL_COPY_READ_BUFFER​, GL_COPY_WRITE_BUFFER​, 0​, 0, size​);
glBindBuffer(GL_COPY_READ_BUFFER, 0);
glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
I have written out 700k points/s to the screen no problem simply by uploading them all into a single VBO and drawing that.