Using std::vector as vertex/element lists with OpenGL - c++

Question

I want to draw a bunch quads.
Right now I have a problem; drawing works fine and is fast but I'm using std::vector as containers for my quads and they're really, really slow. Coming from XNA I figured I should create something like the spriteBatch so that I can just call DrawQuad() to add the given quad to a list and then finally call End() to draw every quad.
My current code generally prints something like this to the console:
DrawQuad(): 77
End(): 0
Over and over again.
Main.cpp (sf::Clock is the clock class in SFML)
sf::Clock time;
for (int y = 0; y < 100; y++)
for (int x = 0; x < 100; x++)
renderer.DrawQuad("A", Vector2<GLfloat>(-1.0f + x * 0.02f, -1.0f + y * 0.02f));
std::cout << "DrawQuad(): " << time.getElapsedTime().asMilliseconds() << std::endl;
Renderer.cpp:
void TextRenderer::DrawQuad(string text, Vector2<GLfloat> position)
{
//TOP LEFT
vertexBufferVector.push_back(position.X);
vertexBufferVector.push_back(position.Y);
//TOP RIGHT
vertexBufferVector.push_back(position.X + 0.02f);
vertexBufferVector.push_back(position.Y);
//BOTTOM RIGHT
vertexBufferVector.push_back(position.X + 0.02f);
vertexBufferVector.push_back(position.Y + 0.02f);
//BOTTOM LEFT
vertexBufferVector.push_back(position.X);
vertexBufferVector.push_back(position.Y + 0.02f);
int elementCount = elementBufferVector.size() / 6;
elementBufferVector.push_back(elementCount * 4);
elementBufferVector.push_back(elementCount * 4 + 1);
elementBufferVector.push_back(elementCount * 4 + 2);
elementBufferVector.push_back(elementCount * 4 + 2);
elementBufferVector.push_back(elementCount * 4 + 3);
elementBufferVector.push_back(elementCount * 4);
}
void TextRenderer::End()
{
sf::Clock time;
GLfloat* vertexArray = &vertexBufferVector[0];
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * vertexBufferVector.size(), vertexArray, GL_STATIC_DRAW);
GLint* elementArray = &elementBufferVector[0];
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint) * elementBufferVector.size(), elementArray, GL_STATIC_DRAW);
glDrawElements(GL_TRIANGLES, elementBufferVector.size(), GL_UNSIGNED_INT, 0);
vertexBufferVector.clear();
elementBufferVector.clear();
std::cout << "End(): " << time.getElapsedTime().asMilliseconds() << std::endl;
}
How do people who know what they're doing solve this? 10000 quads really shouldn't be an issue.
After writing all this I also increased the looping from (100, 100) to (1000, 100) and now the drawing takes 4-5 ms, is that considered good? I'm thinking no...

Answer 1

Since this is dead I'll just answer my question and maybe it'll help someone.
Instead of using vectors I resorted to using arrays with a set size. This brought the total rendering time for 100000 quads (with textures as well) down to an average of ~3.260ms.
My .h looks like this now:
const int MAX_BUFFER_SIZE = 1000;
const int MAX_VERTEX_BUFFER_SIZE = MAX_BUFFER_SIZE * 16;
const int MAX_ELEMENT_BUFFER_SIZE = MAX_BUFFER_SIZE * 6;
...
GLint vertexBufferArrayInserts;
GLfloat vertexBufferArray[MAX_VERTEX_BUFFER_SIZE];
GLint elementBufferArray[MAX_ELEMENT_BUFFER_SIZE];
And the relevant parts of the .cpp file:
void TextRenderer::DrawQuad(Vector2<GLfloat> position)
{
if(vertexBufferArrayInserts == MAX_BUFFER_SIZE)
End();
//TOP LEFT
vertexBufferArray[vertexBufferArrayInserts * 16] = position.X;
vertexBufferArray[vertexBufferArrayInserts * 16 + 1] = position.Y;
vertexBufferArray[vertexBufferArrayInserts * 16 + 2] = 0.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 3] = 0.0f;
//TOP RIGHT
vertexBufferArray[vertexBufferArrayInserts * 16 + 4] = position.X + 16.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 5] = position.Y;
vertexBufferArray[vertexBufferArrayInserts * 16 + 6] = 24.0f / 512.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 7] = 0.0f;
//BOTTOM RIGHT
vertexBufferArray[vertexBufferArrayInserts * 16 + 8] = position.X + 16.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 9] = position.Y + 16.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 10] = 24.0f / 512.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 11] = 32.0f / 512.0f;
//BOTTOM LEFT
vertexBufferArray[vertexBufferArrayInserts * 16 + 12] = position.X;
vertexBufferArray[vertexBufferArrayInserts * 16 + 13] = position.Y + 16.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 14] = 0.0f;
vertexBufferArray[vertexBufferArrayInserts * 16 + 15] = 32.0f / 512.0f;
//ELEMENT BUFFER
elementBufferArray[vertexBufferArrayInserts * 6] = vertexBufferArrayInserts * 4;
elementBufferArray[vertexBufferArrayInserts * 6 + 1] = vertexBufferArrayInserts * 4 + 1;
elementBufferArray[vertexBufferArrayInserts * 6 + 2] = vertexBufferArrayInserts * 4 + 2;
elementBufferArray[vertexBufferArrayInserts * 6 + 3] = vertexBufferArrayInserts * 4 + 2;
elementBufferArray[vertexBufferArrayInserts * 6 + 4] = vertexBufferArrayInserts * 4 + 3;
elementBufferArray[vertexBufferArrayInserts * 6 + 5] = vertexBufferArrayInserts * 4;
vertexBufferArrayInserts++;
}
void TextRenderer::End()
{
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * vertexBufferArrayInserts * 16, vertexBufferArray);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLint) * vertexBufferArrayInserts * 6, elementBufferArray);
glDrawElements(GL_TRIANGLES, vertexBufferArrayInserts * 6, GL_UNSIGNED_INT, 0);
vertexBufferArrayInserts = 0;
}
And this is how I timed it:
sf::Clock timer;
renderer.Begin(projMatrix);
for (int y = 0; y < 100; y++)
for(int x = 0; x < 1000; x++)
renderer.DrawQuad(Vector2<GLfloat>(16.0f * x, 16.0f * y));
renderer.End();
avgDrawTime += timer.getElapsedTime().asMicroseconds();
drawCalls++;
if(drawCalls % 100 == 0)
std::cout << avgDrawTime / drawCalls << std::endl;