OpenGL - Changing blending modes using sprite batching

Question

I'm working on a game which uses sprite batching to render sprites efficiently where each sprite gets batched with its VBO data into a VAO every frame (containing vertex coordinates, texture data and color data). So far so good. I'm sorting them on the CPU and ordering the batch before each draw call according to render order to simulate z-ordering.

However, there's one problem: what do I do when I want to draw particles, for instance, which require a blending mode change? All of the sprites are drawn using glDrawArrays use the same blending mode, but for my particle data I want to change the blending mode. If I put the particles in the same batch then I won't have the ability to change it necessarily. My goal is to switch from normal blending (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) to additive blending (GL_SRC_ALPHA, GL_ONE).

1st solution: use a separate draw call for every sprite and don't batch them at all. then for each call I can change the mode appropriately

2nd solution: add a z-coordinate to each sprite to do z-ordering automatically on the GPU using depth testing (this means I can render particles separately in their respective batches with ~2 calls -> +1 for sprites & +1 for particles) which will allow me to change blending modes.

Is there another way of approaching this problem? What am I missing?

Answer 1

Background

OpenGL blend funcs are just a means of specifying a mathematical formula as follows:

• src: the output from your fragment shader.
• dst: the colour in the framebuffer.
• sfactor: multiply src by this.
• dfactor: multiply dst by this.
• And add the two results together.

(As a simplifying assumption I'm ignoring blend equation, blend func separate and multiple render targets, and also assuming that you don't care about destination alpha).

So if we look at your two blend funcs we see that they work out as follows:

glBlendFunc (GL_SRC_ALPHA, GL_ONE)                  =  src * src.a + dst * 1
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)  =  src * src.a + dst * (1 - src.a)

The objective is to find a way to use a single blend func for everything.

---

I'm going to assume, for the purposes of this answer, that your fragment shader writes it's output to gl_FragColor. If it doesn't, just replace any references to gl_FragColor in the remainder of this answer with whatever you do write to.

---

Let's repeat the two blend funcs again:

src * src.a + dst * 1
src * src.a + dst * (1 - src.a)

The only difference between the two is the value used for dfactor, and it's (1 - src.a) in the latter, so if we can modify our fragment shader to output 0 for src.a in the former case, then the two blend funcs become the same (because 1 - 0 = 1).

However, we see that src.a is also used as sfactor in both, so we can't modify src.a without also affecting that.

Let's see if we can find a way of modifying the fragment shader to remove that restriction. Since we don't care about destination alpha we can just do this:

gl_FragColor.rgb *= gl_FragColor.a;

After having done that, the two blend funcs become:

glBlendFunc (GL_ONE, GL_ONE)
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA)

Or:

src * 1 + dst * 1
src * 1 + dst * (1 - src.a)

So the only remaining thing is to find a means of setting src.a to 0 in the former case; something like this in your fragment shader:

gl_FragColor.rgb *= gl_FragColor.a;
if (altBlend) gl_FragColor.a = 0;

So we want altBlend to evaluate to true in cases where you use GL_ONE, GL_ONE blending, or false in cases where you use GL_ONE, GL_ONE_MINUS_SRC_ALPHA blending, and we have the result; we can now use a single blend func for all drawing:

glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

Or:

src * 1 + dst * (1 - src.a)

And in cases where src.a is 0 this is exactly equivalent to:

src * 1 + dst * (1 - 0)

Or:

src * 1 + dst * 1

Or:

glBlendFunc (GL_ONE, GL_ONE);

---

So all that's remaining is how to set the value of altBlend, and how you do that is entirely up to you. You could set an additional vertex attrib that you pass along to your fragment shader, you could bind an additional texture and sample from it for the different types of objects, or you could do something entirely different; it all depends on which is most appropriate for the rest of your code.

Answer 2

For anyone interested, my solution was to just change blending modes in my sprite batcher by keeping track of the indices where blending modes change and then call glDrawArrays as many times as I need whenever the blending mode changed. They're still batched, but the chunks are as small as the gaps between blending modes.