Hello,
I’m building a basic ground with a bunch of squares made up of two triangles.
I’m storing it in a large array of vertices of size 2001(length)*2001(width)*6(vertices for the two triangles)*3(vertices coords).
So the total triangles number is 24 024 006 (or 72 072 017 vertices).
I know this could be largely optimised (avoiding to reuse same vertices, using VBO) but what bother me here is the framerate I get (20 FPS) as I think this should be no problem for a quite recent hardware (Nvidia GTX 460 M) to display over 24 millions polygons every frame?
I wonder where the problem is and if I’m doing something wrong here.
For instance, Is it a good practice to use a single large VAO buffer or should it be split in several smaller buffers?
Here is some code of the way I’m doing it:
init part:
GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
int range=1000;
int vaoSize = (2*range+1)*(2*range+1)*6*3;
GLfloat g_vertex_buffer_data[vaoSize];
cout<<"vao mem consumption: "<<sizeof(g_vertex_buffer_data)<<endl;
size_t index = 0;
for(int x=-range; x<=range; x++){
for(int z=-range; z<=range; z++){
//FIRST TRIANGLE
//vertice 1
g_vertex_buffer_data[index++] = x;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z;
//vertice 2
g_vertex_buffer_data[index++] = x+1;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z;
//vertice 3
g_vertex_buffer_data[index++] = x;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z+1;
//SECOND TRIANGLE
//vertice 4
g_vertex_buffer_data[index++] = x+1;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z;
//vertice 5
g_vertex_buffer_data[index++] = x+1;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z+1;
//vertice 6
g_vertex_buffer_data[index++] = x;
g_vertex_buffer_data[index++] = 0.0f;
g_vertex_buffer_data[index++] = z+1;
}
}
cout<<"total vertices: "<<--index<<" | total triangles: "<<index/3<<endl;
// This will identify our vertex buffer
GLuint vertexbuffer;
// Generate 1 buffer, put the resulting identifier in vertexbuffer
glGenBuffers(1, &vertexbuffer);
// The following commands will talk about our 'vertexbuffer' buffer
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
// Give our vertices to OpenGL.
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
then in the main loop I use this code to display the array along with some other usual Opengl calls:
// 1rst attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(
0, // attribute 0. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);
// Draw the triangles !
glDrawArrays(GL_TRIANGLES, 0, vaoSize/3);
glDisableVertexAttribArray(0);
If you have any clue to spot this performance issue, I would really appreciate!