OpenGL quad rendering optimization

Question

I'm drawing quads in openGL. My question is, is there any additional performance gain from this:

// Method #1

glBegin(GL_QUADS);
// Define vertices for 10 quads
glEnd();

... over doing this for each of the 10 quads:

// Method #2

glBegin(GL_QUADS);
// Define vertices for first quad
glEnd();

glBegin(GL_QUADS);
// Define vertices for second quad
glEnd();

//etc...

All of the quads use the same texture in this case.

Answer 1

I believe the answer is yes, but you should try it out yourself. Write something to draws 100k quads and see if one is much faster. Then report your results here :)

schnaader: What is meant in the document you read is that you should not have non-gl related code between glBegin and glEnd. They do not mean that you should call it multiple times over calling it in short bits.

Answer 2

I suppose that you get the highest performance gain by reusing the vertices. To achieve that, you would require to maintain some structure for primitives yourself.

Answer 3

Yes, the first is faster, because each call to glBegin or glEnd changes the OpenGL state.

Even better, however, than one call to glBegin and glEnd (if you have a significant number of vertices), is to pass all of your vertices with glVertexPointer (and friends), and then make one call to glDrawArrays or glDrawElements. This will send all your vertices to the GPU in one fell swoop, instead of incrementally by calling glVertex3f repeatedly.

Answer 4

From a function call overhead perspective the second approach is more expensive. If instead of ten quads we used ten thousand. Then glBegin/glEnd would be called ten thousand times per frame instead of once.

More importantly glBegin/glEnd have been deprecated as of OpenGL 3.0, and are not supported by OpenGL ES.

Instead vertices are uploaded as vertex arrays using calls such as glDrawArrays. Tutorial and much more in depth information can be found on the NeHe site.

Answer 5

I decided to go ahead and benchmark it using a loop of 10,000 quads.

The results:

Method 1: 0.0128 seconds

Method 2: 0.0132 seconds

Method #1 does have some improvement, but the improvement is very marginal (3%). It's probably nothing more than the overhead of simply calling more functions. So it's likely that OpenGL itself doesn't get any additional optimization from Method #1.

This is on Windows XP service pack 3 using OpenGL 2.0 and visual studio 2005.

Answer 6

You would get better performance for sure in just how much code gets called by the CPU.

Whether or not your drawing performance would be better on the GPU, that would completely depend on the implementation of the driver for your 3d graphics card. You could get potentially wildly different results with a different manufacturer's driver and even with a different version of the driver for the same card.