Uploading multiple objects to GPU asynchronously - c++

Question

I have a a bunch of 3D models from the stereo camera on the Curiosity rover driving around on Mars. The models are being loaded from disk, multiple models at the same time, asynchronously. Now I need to upload this bunch of models asynchronously to the GPU(at runtime) to prevent a stall in the rendering loop, which is happening right now.
The way a model is uploaded right now:
glGenVertexArrays(1, &_vaoID);
glGenBuffers(1, &_vbo);
glGenBuffers(1, &_ibo);
glBindVertexArray(_vaoID);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(Vertex), _vertices.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
reinterpret_cast<const GLvoid*>(offsetof(Vertex, location)));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex)));
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(int), _indices.data(), GL_STATIC_DRAW);
glBindVertexArray(0);
And the way it is rendered:
glBindVertexArray(_vaoID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
glDrawElements(_mode, static_cast<GLsizei>(_indices.size()), GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
Right now I am uploading about 20 models to the GPU each time in the renderloop(when there are models loaded from disk and ready to be uploaded to the GPU) and it's way to much, the application stalls for about 50-400ms depending on the amount of vertices/normals/indices for the models.
Ping ponging between VBOs(updating one, reading from one) will probably not work in the current pipeline since each model has a random amount of vertices/normals/indices and needs to be connected to one specific texture.
I'm looking for any solution improving the performance.
Edit 1
I have now successfully created pointers to my VBO and IBO, however I'm confused how I'm supposed to unmap the buffers when they are returned to the main thread. My first thought was to unmap the VBO and IBO individually like this:
`
for (int i = 0; i < _vertices.size(); i++) {
_vertexBufferData[i] = _vertices.at(i);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
for (int k = 0; k < _indices.size(); k++) {
_indexBufferData[k] = _indices.at(k);
}
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
But i get an error saying that the buffer is already unbound or unmapped. Do I only have to do the first unmap?

Answer 1

The problem you describe is called Buffer Object Streaming.
In a few words, say you got a trigger that a specific model has to be loaded. Then:
Create the VAO and VBOs as you described, but without loading any data yet. You use glBufferStorage for this.
Map the buffer into your memory and launch a thread to fill that buffer with the data. The thread will do all the time consuming disk i/o and filling of the mapped memory region.
When the worker thread is done, notify the main thread.
In the main thread, once you got the notification, unmap the buffers and mark the VAO as loaded for subsequent rendering.
Obviously between 1 and 4 your main thread continues rendering as usual, without rendering that pending VAO.