Mesh rendering performance optimisation

Question

I'm working on a libgdx implementation of mesh terrain and running into some performance issues.

The terrain is represented by a number of mesh tiles, each mesh is made of vertices laid onto a 2D plane.

The implementation of the meshes is done via libgdx Mesh, each of which is cached after its initial generation. I use GL3.0 and therefore the vertices are handled via VertexBufferObjectWithVAO which as I understand it should allow GPU caching. Meshes are indexed.

Aiming to optimise performance, I have tried to increase the number of vertices in each mesh (while keeping the same overall amount of vertices) but weirdly the performance gets worse rather than improving.

Question 1: any possible reasons why given the same total number of vertices the scenario with lower amount of meshes (#3 below) is slower than the scenarios with higher number of meshes?

Question 2: based on the OPENGL pipeline summarised below is it correct to assume that VBOs are being transferred to the GPU once and then drawn via GPU memory reference?

Performance comparison

1. 1,600 meshes * 3,042 vert (4.8M vertices) -> 131 FPS

2. 625 meshes * 11,250 vert (4.5M vertices) -> 132 FPS

3. 100 meshes * 45,000 vert (4.5M vertices) -> 113 FPS

Hardware Details

GTX660 2GB Memory Utilisation during test 70% in all scenarios. Vertex allocation memory impact seems to be negligible compared to textures.

OPENGL pipeline

From API TRACE, this is the frame life-cycle in summary

mesh generation (one off)

glGenBuffers()
glGenVertexArrays()

render (every frame)

glClear(GL_COLOR_BUFFER_BIT)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glUseProgram(...)
glUniformMatrix4fv(...)
glUniform1f(...)
glActiveTexture(...)
glBindTexture(...)
...
glBindVertexArray(...)
glBindBuffer(...)
glDrawElements(...)
[for each mesh]

*edited to clarify that I have tried to group the vertices into less amount of meshes to reduce number of draw calls

**edited to provide more data and streamline questions.

Answer 1

There could be a number of reasons why performance is sluggish, I'll mention some of which I think are the biggest ones, based on your question:

• Bigger mesh does not mean less performance-intensive. Assuming a mesh is clearly visible by the camera (not cut-off) then the smallest it is, the less pixels have to calculate how to draw it (in shaders).
• The idea on VBO is that you give a mesh to the GPU, and then you can draw that mesh multiple times on different places. In your case that you are drawing a terrain, if it's anything similar to games like minecraft, you'd only need to upload to the GPU a few different meshes, and then you'd be able to draw massive amounts of land with them.
• A classic trap new people fall into is that they think the whole virtual world is always active and being drawn. That is not the case. No matter how big your map is, you'd almost never draw all of it. Divine it into chunks, load only the ones closest to the player. If the player is approaching the edge of a chunk, load the next one. With this method you can make "infinite" worlds without performance suffering.