Jump to content
  • Advertisement
Sign in to follow this  
XTAL256

OpenGL Transparency using glDrawPixels

This topic is 3720 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Does OpenGL use pre-multiplied alpha? I can't find anything about it in the red book or even on google but i have been using the SOIL library with my game for a while now an i use it with the flag SOIL_FLAG_MULTIPLY_ALPHA. When i use it without this some of my images have while where it should be transparent. That was for my GUI, now i am up to writing the code for the game maps and (for various reasons) i am using raw pixel data instead of GL textures. But i don't know if i need to pre-multiply the pixel data. I tried with and without and it definitely seems to use pre-multiplied alpha. But the background of the image is still black. I am drawing the pixel data over the top of a textured quad and the image should show the texture through the transparent parts. Well, i'll just show you... The blend function is (GL_ONE, GL_ONE_MINUS_SRC_ALPHA). [Edited by - XTAL256 on July 27, 2008 9:50:09 PM]

Share this post


Link to post
Share on other sites
Advertisement
Quote:
Original post by XTAL256
Does OpenGL use pre-multiplied alpha?

No, it doesn't.

As to why you don't get transparency, there can be lots of reasons - blending not enabled, alpha channel not transferred, incorrectly configured pixel transfer pipeline, etc. You don't provide enough information to proceed any further than pure speculation.

Share this post


Link to post
Share on other sites
Gl uses whatever blend mode you tell it to. By looking at your blend function it seems like you are using pre-multiplied alpha. Make sure you have all relevant alpha options turned on, and that you are using alpha format for your texture.

Share this post


Link to post
Share on other sites
Oh yeah, I didn't notice that you use a strange blending mode.

The best and most straightforward way is to use (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). Your alpha value then simply represents opacity.

Share this post


Link to post
Share on other sites
Quote:
Original post by Yann L
Oh yeah, I didn't notice that you use a strange blending mode.

The best and most straightforward way is to use (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). Your alpha value then simply represents opacity.



That's not "the best", it has all sorts of problems compared to premultiplied: http://home.comcast.net/~tom_forsyth/blog.wiki.html#%5B%5BPremultiplied%20alpha%5D%5D

Both are equally straightforward as they involve setting the blending mode.

I'm guessing previous posters are correct and part of the state is missing (i.e blending disabled, etc).

Share this post


Link to post
Share on other sites
Quote:
Original post by raigan
That's not "the best", it has all sorts of problems compared to premultiplied: http://home.comcast.net/~tom_forsyth/blog.wiki.html#%5B%5BPremultiplied%20alpha%5D%5D

And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.

Premultiplied alpha is in no way more 'correct' than standard alpha blending. Physically, they're both entirely wrong. However, while premultiplied alpha can have its uses in image composition (keep in mind that it was originally designed to speed up CPU blending !), it is often more incorrect than standard alpha blending when introducing concepts such as HDR, non-linear blending or the dreaded HDR-MSAA-Tonemapping combo. And with modern programmable pipelines, what do you call 'pre'-multiplied alpha anyway ? When does the post-multiply become a pre-multiply ? It doesn't really make any sense.

This article cites the whole DXT compression deal as an advantage for premultiplied alpha. That is entirely incorrect. This is strictly a question about the behaviour of lossy compression algorithms regarding to edge cases, especially colour values that are totally transparent. Premultiplying them with alpha is in no way a guarantee to increase DXT compression quality. Infact, while it might improve quality on some images, it can seriously degrade quality on others. And beside doing nothing (ie. leaving the colour values as-is) or multiplying with alpha, there are a whole pile of other techniques that consistently improve quality on almost all cases, and that have absolutely nothing to do with premultiplied alpha.

Whether or not this is what the OP is after is another question. I have personally never felt the need for PM alpha. If you don't need physically correct blending, then standard alpha is perfectly fine and gives you the option to modify transparency on the fly. If you need physically correct transparency, then you can't use the standard blending pipeline anyway.

Share this post


Link to post
Share on other sites
I'm kind of a n00b when it comes to OpenGL. I am just making this game as a hobby, i never took any courses on OGL and i haven't read all of the red book. I know the basics of OGL and i even made a Windows Media Player visualisation using it but i never understood how to do alpha blending. When i tried the mode that i thought would work, i just got black where it should have been transparent. So when i started making my game i used SOIL for loading images and for reasons i can no longer remember i used GL_ONE, GL_ONE_MINUS_SRC_ALPHA as the blend mode. I just set blend mode to what you said (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA without pre-multiplied alpha) and it works just the same, so i'll use that.
But i still can't get the map to draw properly. I worked out (before i posted this) that i needed to disable textures before drawing pixels but do i also need to turn off alpha blending? Because it still doesn't work if i do. I know it's hard to help me if i don't provide much info but i don't know where the problem is. Here is some of the code:

/// Map.h /////////////////////////
class Map {
public:
static Vector<Map*> maps; // List of all Maps
static void loadMaps(); // Load Maps from Map directory

public:
bool isCreated; // If the map has been created
String name, description;
String dir; // Directory where map data is
Image* preview; // Preview image to show in GUI
int width, height; // Size of map (px)
Rect view; // Area in view on screen
int maxPlayers; // Maximum number of players
Image* background; // Background image
int bgTileMode; // Whether to tile or stretch background
unsigned char* image; // Map image
unsigned char* terrain; // Terrain map

Map() : isCreated(false) {}
~Map();
void load(String &filename);
void create();
void distroy();
void draw();
};

/// Map.cpp ///////////////////////
void Map::draw() {
drawImage(background, 0, 0, 800, 450); // Draws a texture mapped quad with background image on it
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glRasterPos2i(100, 300); // These values are just for debugging
glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, image);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
}


The image is made up of smaller tile images but basically the image data is loaded using SOIL_load_image (see SOIL docs). When i don't use pre-multiplied alpha (and using the blend mode you guys suggested) the transparent areas are white but when i do use it the transparent areas are black, which i assume is transparent because the background is black.

Share this post


Link to post
Share on other sites
Quote:
Original post by Yann L
And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.



Having to resort to complex, ad-hoc pre-processing in order to avoid weird halos around the edges of transparent textures is what makes the standard method awkward, non-intuitive (especially for beginners) and pretty damn stupid: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLPages/WhiteHalo2.html

Compression aside, what are the "even more" problems with PM?

Share this post


Link to post
Share on other sites
Quote:
Original post by raigan
Quote:
Original post by Yann L
And premultiplied alpha has even more problems that (conveniently) aren't mentioned in that article. Standard alpha blending is the 'best' in the sense that it is the easiest, most intuitive and most flexible method that is achievable with todays' non-programmable blending stages.



Having to resort to complex, ad-hoc pre-processing in order to avoid weird halos around the edges of transparent textures is what makes the standard method awkward, non-intuitive (especially for beginners) and pretty damn stupid: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLPages/WhiteHalo2.html

That's a photoshop/content creation issue that has nothing to do with pre-multiplied vs. non-pre-multiplied. PEBKAC.

Share this post


Link to post
Share on other sites
I guess I wasn't clear -- this image on that page specifically shows the sort of thing you have to do (either via the plugin on that page OR your own pre-process) to make sure that fully transparent pixels are colored to avoid haloing: http://www.robinwood.com/Catalog/Technical/SL-Tuts/SLGraphics/Halo/Halo12-Solidified.jpg

Color from fully transparent pixels being "pulled in" by texture filtering isn't a Photoshop/content creation issue, it's a direct result of the non-PM blending formula.

Another way to look at it is that non-PM will always lerp both color and alpha channels at the same time, which is not what you want at the edges of transparencies -- you want the alpha to lerp to 0 while the color stays constant. This is impossible to achieve with non-PM blending, and pre-processing images to "bleed" the correct color into fully transparent texels is a common work-around, not a proper solution.

PM lets you avoid this problem, which is the main reason to use it IMHO; I thought this was a well-known issue, or else I would have been more specific with the example link.. it was just the first one I came across.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!