渲染具有透明度的纹理时，OpenGL不需要的像素

Question

I've been struggling with this problem for a while now. When I use OpenGL to render 2D textures, which have transparency values on the transition between no transparency and some transparency, I get some annoying grey pixel which I assume are a product of pixel value interpolation. Any ideas on how I can improve that?

I'm attaching an image to exemplify what I'm talking about:

Not that I think it will make a difference but I'm using Qt to create a QGLWidget and C++.

SOLVED:

I've been trying to solve this problem for a while. I tried using images with pre-multiplied alpha channel, using separate blend functions for color and alpha... For me nothing worked, I've might have done it wrong, I don't know. For me what worked was exporting the .png image with Anti-Aliasing: Type Optimized (Hinted) on Adobe Illustrator and using glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

Hope this helps other people with the same problem :)

Thank you again for the awnsers.

Answer 1

Short answer: Nicol Bolas is right that you should investigate pre-multiplied alpha, and here's the math that explains why.

Why it won't work correctly

Here's how things work with non-premultiplied alpha.

When you composite a source texture with color and alpha (C _S , α _S ) onto a destination (C _D , α _D ), you get the formula:

C = α _S C _S + (1 - α _S ) C _D

Now, if we have layer two textures, first (C ₁ , α ₁ ) and then (C ₂ , α ₂ ), we get the formula:

C = α ₂ C ₂ + (1 - α ₂ ) (α ₁ C ₁ + (1 - α ₁ ) C _D )

If we want to do this in one step with a pre-composited texture, like the way you are rendering to a texture, we need to rearrange this formula to match the original formula:

C = (α ₂ C ₂ + (1 - α ₂ ) α ₁ C ₁ ) + (1 - α ₂ ) (1 - α ₁ ) C _D

α _S C _S = α ₂ C ₂ + (1 - α ₂ ) α ₁ C ₁

(1 - α _S ) C _D = (1 - α ₂ ) (1 - α ₁ ) C _D

We can solve for α _S :

α _S = 1 - (1 - α ₁ ) (1 - α ₂ ) = α ₁ + α ₂ - α ₁ α ₂

But when we then solve for C _S :

C _S = (α ₂ C ₂ + (1 - α ₂ ) α ₁ C ₁ ) / (α ₁ + α ₂ - α ₁ α ₂ )

There's no OpenGL blending mode that lets us calculate C _S correctly.

What if alpha is pre-multiplied?

The formula for pre-multiplied alpha blending is different:

C = C _S + (1 - α _S ) C _D

With two textures,

C = C ₂ + (1 - α ₂ ) (C ₁ + (1 - α ₁ ) C _D )

When we rearrange to match the first formula, we get:

C = C ₂ + (1 - α ₂ ) C ₁ + (1 - α ₂ ) (1 - α ₁ ) C _D

Then we solve:

α _S = 1 - (1 - α ₁ ) (1 - α ₂ ) = α ₁ + α ₂ - α ₁ α ₂

C _S = C ₂ + (1 - α ₂ ) C ₁

This is just the same as:

glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

So, if you use pre-multiplied alpha for all of your textures, then all the math works out perfectly, and you don't have to worry about this stuff. Just use that same blend function everywhere, use pre-multiplied alpha everywhere, and you can composite things in any order you like.

Pre-multiplied alpha also interpolates correctly, which is not true of non-premultiplied alpha, but this is a separate issue.

Summary

The pre-multiplied composition operator is associative which means that you can take a bunch of layers and squash them into one texture, exactly the way you want.

Without pre-multiplied alpha, the math doesn't work out the way you want.