OpenGL 4 several glUseProgram overhead

Question

I'm developing a little 2D game using OpenGL 4.x and I've also coded a very simple light system which does not take care of shadows. The main concept behind this light system is the frambuffer multiplicative blending. I basically have two framebuffers, one for the normal scene render and the other one for ambient light and the scene light sources. Then, I blend those two framebuffers and I get my final result (which is pretty good, to be honest).

In this model I have 3 different shader programs:

• One for rendering the normal scene (with texturing and other normal features)
• One for rendering lights, which compute light halos and other light effects
• One for blending the two framebuffers together

Now, in my main application loop I have to switch between those three shader programs in order to complete a full rendering cycle. I'm also planning to add more shaders to render different light effects and particles. At the moment I'm in the design phase of my game, so I'm not able to test out the performance of this approach and I have no previous experience with it. And for the same reason I'd like to start with the best approach possibile for this situation.

So my question is: considering your experience, is switching between several shader programs at each frame something good or is it a bad behaviour in a 2D enviroment ? Is using fewer shader programs but with more if statement and more unused uniform variables a better solution?

Answer 1

In general, the fewer state changes the better. However, as state changes are unavoidable, there are some ways you can consider how to reduce the number of them.

Group/sort entities by shader/texture/mesh etc, so that you draw a bunch of stuff for each group with as few state changes as possible. To be honest though, as you are in the design phase, I wouldn't worry about this too much.

Get stuff working first, then optimise.

Answer 2

The best way to find out is to try both options and measure performance since this is not as easy to predict as it seems.

But there are a few points to keep in mind. One is that GLSL is not very good at branching. So while setting a uniform and then switch in the shader might look like a good idea because it reduces calling glUseProgram but can result in a worse performance since the graphics card is bad at branching.
Grouping shaders together and switch between these shaders might better. But in the end you should try both options and measure performance. When you decide to use less shaders and set options with uniforms I recommend to sort the vectors or whatever data structure you use by the uniform values and render them then.
But always measure performance in release builds and then decide. Also don't optimize to early. When the shaders are very simple and get more complex later the first performance runs might not be significant for the current system.

In this tutorial the same is said about branching in shader code.