Most likely because the fully transparent parts of your texture contain values (1.0, 1.0, 1.0, 0.0), so when linear interpolation around the edges causes the alpha value to be > 0, passing the alpha test in your fragment shader you get a value that is a mix of blue and white.
Use textures that store values with pre-multiplied alpha and corresponding blend mode or pad the edges of opaque areas with the nearby color to avoid this.
This is usually caused by the transparent colour bleeding into pixels with partial alpha as a result of linear filtering or mipmap generation. The transparent colour for this image is white. Either set the transparent colour to match the rest of the image (0,0,178) or convert to pre-multiplied alpha after loading (and change the blending mode accordingly).
It should be 0,0,178. 255 is too bright. Also, try changing it to something completely different like 255,0,0,0 just to see if you’re actually changing what you think you’re changing.
That isn’t necessary if the transparent colour is changed to match the rest of the image (which is 0,0,178). Note that changing the blending mode requires converting the image to use pre-multiplied alpha, not just fixing the transparent colour.
Replace [r,g,b,a] with [a*r,a*g,a*b,a]. Any pixel with zero alpha will be [0,0,0,0].
Change the blending mode to glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA). The source colour has already been multiplied by its alpha so you don’t need GL_SRC_ALPHA as the source factor.
Currently, I am processing the image this way. The source bitmap has full ‘blue’ areas, full ‘transparent’ areas, and some antialiased pixels between them.
public static Bitmap ChangeColor(Bitmap source)
{
Bitmap dest = new Bitmap(source.Width, source.Height);
for (int i = 0; i < source.Width; i++)
{
for (int j = 0; j < source.Height; j++)
{
Color prevColor = source.GetPixel(i, j);
if (prevColor.A > 0)
dest.SetPixel(i, j, Color.FromArgb(prevColor.A, prevColor.R * prevColor.A/255, prevColor.G * prevColor.A/255, prevColor.B * prevColor.A/255));
else
dest.SetPixel(i, j, Color.FromArgb(0,0,0,0));
}
}
return dest;
}
What am I doing wrong? I’ve tried standard blending and glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA) blending.
No idea. That function is correctly converting to pre-multiplied alpha. Based upon the original image, every pixel should have r=0, g=0, b=178*a/255. IOW, there shouldn’t be any white pixels in the image (write a test to check this). If you’re still seeing them, I’d guess that you’re uploading the original image rather than the fixed copy.
Are you drawing the points last? You can’t rely upon depth testing if you’re using blending. You can use depth testing with alpha testing (i.e. treating the alpha channel as a binary mask), but not with blending. If you’re using blending, anything with partial alpha has to be rendered from back to front.
If you try to use depth testing with blending, any fragment with partial alpha will get blended against the framebuffer contents at the time it is rendered and update the depth buffer. Anything drawn behind it will then get discarded (and not affect the pixel colour).
Is this performing integer or floating point math?
Also, completely unrelated: when processing image data I would recommend making the outer loop over y (height) so that the inner loop processes adjacent pixels in a row which are much more likely in cache.
My apologies, I originally didn’t see that you’d suggested this before I did. But yes, that’s clearly what’s happening here. The point sprites are being drawn first, they’re alpha blending with the white background, then when the other geometry is drawn they get white fringes.
