1

This is a two part question. I am rendering some BSP geometry and some of the textures have an alpha color which should be invisible.

So the first step would be figuring out the alpha color so I can correctly render it. I uploaded a sample bitmap:

Image

As you can see, it is a railing texture where RGB(160,158,148) is the color that should be invisible. I can figure this out just by looking at it. The problem is, how do I find this value in the file?

So that is step one. The second is an OpenGL issue where I am rendering a bunch of geometry with vertex arrays. How do I accommodate for the fact a color needs to be removed from the texture when rendered? Do I need to render this in a specific order? Also, I should mention I am using SDL if that helps make any of this a bit easier.

Thank you both for fantastic answers. I wish I could pick both of you...

Satchmo Brown
  • 1,409
  • 2
  • 20
  • 47

2 Answers2

3

and some of the textures have an alpha color which should be invisible.

This is actually called a keying color.

The alpha channel is an additional channel, adding to the "normal" RGB channels. When alpha blending is used, one uses the alpha channel value as opacity.

I can figure this out just by looking at it. The problem is, how do I find this value in the file?

If a color key is used, one uses either some specific color, used for all images, or stores the keying value separately, loading it with the image file. Another common technique is to use the value of the upper left pixels as keying color.

How do I accommodate for the fact a color needs to be removed from the texture when rendered?

By preparing the image data with a color key generated alpha channel:

for(i = 0; i < pixelcount; i++) {
    if( source[i].r == key.r && source[i].g == key.g && source[i].b == key.b ) {
        dest[i].r = dest[i].g = dest[i].b = dest[i].a = 0;
        continue;
    }
    dest[i].r = source[i].r;
    dest[i].g = source[i].g;
    dest[i].b = source[i].b;
    dest[i].a = 255;
}

Update: In the case of color key generated alpha channel, one can use alpha testing instead of blending. The nice thing with alpha testing is, that it doesn't requires to depth sort the geometry prior to drawing.

glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5);

The ideal way would be to use a image file format with alpha channel support (PNG, TGA, OpenEXR, …), and not using BMPs (actually the BMP file format would allow for a 4th channel, and in fact I once wrote my own BMP loader with alpha channel support, and a Photoshop export plugin, many years ago).

datenwolf
  • 159,371
  • 13
  • 185
  • 298
  • Okay. So if I prepare the data with a color key, do I need to sort the surfaces at all before I render? How does the rendering process work as opposed to a normal rendering process where all the textures are opaque? – Satchmo Brown Nov 02 '11 at 23:14
  • @SatchmoBrown: See my update for an alternative method, called alpha testing. – datenwolf Nov 03 '11 at 00:21
  • Thanks. What if I was to figure out the color to be used for the alpha transparency (top left corner method perhaps) and then save the alpha value into the struct. And then when rendering, I am still confused. Would I set that color value to a specific number that would be recognized by the alpha testing. Any suggestions? Thanks again by the way. – Satchmo Brown Nov 03 '11 at 00:58
  • I guess a better way to ask if imagine I am doing a rendering call for each texture as I do when rendering with vertex arrays. I could flag the texture in its struct as semi transparent and then associate an RGB flag which is the color to not render. Given a method like that, how could I render with the above process OR how do I set the alpha transparency of that color in that texture to not be rendered. Hope I am making sense. – Satchmo Brown Nov 03 '11 at 01:11
  • @SatchmoBrown: One could implement color keying using a fragment shader. But I stronly suggest you do a color key → alpha conversion like I suggested. Uploading a texture is a one time process, i.e. after initializing a texture with data you use it by simply binding it. Alas, I think I should write a small example program for demonstration, as soon as I find the time. – datenwolf Nov 03 '11 at 08:12
2

Alpha testing is my go-to technique if I want full transparency. No sorting needed.

As far as your image goes convert it to a PNG and set your alpha to zero for each RGB(160,158,148) pixel and 255 everywhere else. Then you can use the alpha test.

You may need to change your RGB(160,158,148) pixels to RGB(255,255,255) to avoid some odd haloing with GL_LINEAR filtering. But it's been a while and I'm not 100% sure on that.

genpfault
  • 51,148
  • 11
  • 85
  • 139
  • 1
    I'd think that you'd change the transparent pixels to RGB(0,0,0), since that would correspond to premultiplied alpha. – JWWalker Nov 02 '11 at 22:18
  • Alpha testing looks great. However, as far as the .bmp goes, I would like to keep it as a bitmap image because I am loading images from an archive of an old game and don't want my software to be encumbered by possible legal issues. Also, alpha testing looks great but the problem is finding what color needs to be discarded. How would I find out from that .bmp what values are actually of interest (160, 158, 148) in the example provided. – Satchmo Brown Nov 02 '11 at 22:23
  • Also, I am curious as to whether you use the fixed function version of alpha testing or the shader version. – Satchmo Brown Nov 02 '11 at 22:26
  • @Satchmo: So you want your program to figure out which particular RGB triplet is the "right" one for colorkeying? Automatically? Not sure you could do that in general. Depending on your image set you might be able to come up with workable heuristics though. Maybe do a histogram and assume the most numerous color is your colorkey. – genpfault Nov 03 '11 at 05:28
  • @Satchmo: I've only used the fixed-function variant. Too many GMA950's out there :( The intersection of OpenGL 1.4 and ES 1.1 seems to be the sweet spot for maximal hardware support. – genpfault Nov 03 '11 at 05:28