OpenGL VBO vs. Immediate-Mode performance problem

[Accname]

Hi guys. I hope someone around here knows a lot about openGL.

I switched to VBO's after working with immediate mode for a bit, and to my surprise the performance didnt improve at all!? It got even slightly worse Oo.

I made a simple example program where I attempt to draw 20000 quads, once with immediate mode and once with a VBO (and glTranslate). I tried to trim the program to the essential parts:

    public class SomeScene {

        private XRect[] rects;
        private int vbo_id;
        private int ibo_id;
        
        private static final int IMAGE_COUNT = 20000;
        
        public void update() {
            GL11.glBegin(GL11.GL_QUADS);
            for (int i = 0; i < IMAGE_COUNT; i++) {
                GL11.glVertex3f(rects[i].get_x(), rects[i].get_y(), 0);
                GL11.glVertex3f(rects[i].get_x(), rects[i].get_final_y(), 0);
                GL11.glVertex3f(rects[i].get_final_x(), rects[i].get_final_y(), 0);
                GL11.glVertex3f(rects[i].get_final_x(), rects[i].get_y(), 0);
            }
            GL11.glEnd();
            /*
            * GL11.glMatrixMode(GL11.GL_MODELVIEW);
            * for (int i = 0; i < IMAGE_COUNT; i++) {
            *     GL11.glPushMatrix();
            *     GL11.glTranslatef(rects[i].get_x(), rects[i].get_y(), 0);
            *     GL11.glDrawElements(GL11.GL_TRIANGLES, 6, GL11.GL_UNSIGNED_BYTE, 0);
            *     GL11.glPopMatrix();
            * }
            */
        }
        
        public void initialize() {
            load_rects();
            load_vbo();
        }
        
        private void load_rects() {
            rects = new XRect[IMAGE_COUNT];
            for (int i = 0; i < IMAGE_COUNT; i++) {
                float x = (float) (Math.random() * XProgram.get_display_width());
                float y = (float) (Math.random() * XProgram.get_display_height());
                rects[i] = new XRect(x, y, 32, 32);
            }
        }
        
        private void load_vbo() {
            int FLOAT_BYTE_SIZE = 4;
            /*
             * Define vertices and indices used by the VBO:
             */
            float[] vertices = new float[] {
                    0, 0, 0,
                    0, 32, 0,
                    32, 32, 0,
                    32, 0, 0
            };
            byte[] indices = new byte[] {
                    0, 1, 2, 2, 3, 0
            };
            
            /*
             * Create the vertex buffer; upload vertices into buffer.
             */
            vbo_id = GL15.glGenBuffers();
            FloatBuffer vbo_buf = ByteBuffer.allocateDirect(vertices.length * FLOAT_BYTE_SIZE).order(ByteOrder.nativeOrder()).asFloatBuffer();
            vbo_buf.put(vertices);
            vbo_buf.flip();
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo_id);
            GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vbo_buf, GL15.GL_STATIC_DRAW);
            
            /*
             * Create the index buffer; upload indices into buffer.
             */
            ibo_id = GL15.glGenBuffers();
            ByteBuffer ibo_buf = ByteBuffer.allocateDirect(indices.length).order(ByteOrder.nativeOrder());
            ibo_buf.put(indices);
            ibo_buf.flip();
            GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, ibo_id);
            GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, ibo_buf, GL15.GL_STATIC_DRAW);
            
            /*
             * Make vbo ready for drawing:
             */
            int POS_COUNT = 3;
            int TEXCOORD_COUNT = 0;
            int stride = (POS_COUNT + TEXCOORD_COUNT) * FLOAT_BYTE_SIZE;
            
            GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
            //GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
            GL11.glVertexPointer(3, GL11.GL_FLOAT, stride, 0);
            //GL11.glTexCoordPointer(2, GL11.GL_FLOAT, stride, POS_COUNT * FLOAT_BYTE_SIZE);
        }
    }

I obviously left quite a bit out (context creation and loop), but that is equal for either modes and thus should not change the outcome of the comparison.

With immediate mode I get 41 fps.
With the VBO I only get around 38 fps and pending between 35 and 40.

What am I doing wrong?

 

[TheDamien]

You're not going to see any performance improvements if your VBO is just a quad and then you call glDrawElements 20000 times a frame. This is not the intended usage pattern of VBOs. Pack all 20000 quads into a single VBO and then you only need to call glDrawElements once a frame.

 

[Accname]

There should still be some change. After all, I dont need to send the vertex data to the graphics card every frame. It is already stored on the graphics cards own memory and I only tell it to draw.
Well, there should be a slight improvement at least, or not?

 

[TheDamien]

The vertex data you're sending per quad is very minimal. The overhead on those function calls is more significant. glDrawElement calls in particular are fairly expensive.