Alpha buffer With 2D Soft Shadows (SOLVED!)

Started by
6 comments, last by OrangyTang 18 years, 10 months ago
I feel like such an idiot but I can't seem to figure this one out! On a bit of a whim I decided to try and implement the 2D soft shadows described Here in my current program. The setup of my program seemed a prefect fit for the alorithim but... I can't get it to work. At all. Not even the first step! AUGH! I haven't the foggiest idea where I'm going wrong. What I've been trying to do thus far is: a) Write the (alpha only) "light" to the framebuffers alpha component. b) Render my normal geometry modulating it by the newly written to alpha channel. This doesn't work, and all I seem to get is the normal geometry, thouh it blends additively if I've got any overlaping polys. I've tried a billion different combinations but none of them work. I've searched through the fourms and all throughout the web, but no one else seems to be having this problem. So, a few ideas of where my problem might be. For one: I don't need to do anything special to create an alpha channel in my frame buffer, do I? Here's my current code:

PIXELFORMATDESCRIPTOR pfd;

ZeroMemory( &pfd, sizeof(PIXELFORMATDESCRIPTOR) );

pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = createParams.colorDepth; //32 in this case
pfd.cDepthBits = createParams.zDepth; //16 here (don't need a 24 bit one)
pfd.cStencilBits = 1;



I would ASSUME that specifying a 32 bit RGBA format should do the trick, but I've been known to be wrong before... Next, Rendering the light (only one for now) I run through something like this:

int cLight::Render( void )
{
	int numSubdivisions = 32;
	float angle;
    
	glDisable(GL_BLEND);
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
        
        //Clear the alpha buffer to 0	
	glPushMatrix();
	glLoadIdentity();
	
	glColor4f(0.0f, 0.0f, 0.0f, 0.0f);

	glBegin(GL_QUADS);
		glVertex2f( 0, 0 );
		glVertex2f( 1024, 0 );
		glVertex2f( 1024, 768 );
		glVertex2f( 0, 768 );
	glEnd();

	glPopMatrix();
	
	glBegin(GL_TRIANGLE_FAN);
	
        //This stuff is pretty much direct from the tutorial
        glColor4f(1.0f, 1.0f, 1.0f, intensity);
        glVertex3f(position.x, position.y, 0.0f);
      
        // Set edge colour for rest of shape
        glColor4f(0.0f, 0.0f, 0.0f, 0.0f);
      
        for (angle=0; angle<=PI*2; angle+=((PI*2)/numSubdivisions) )
        {
            glVertex3f( range*(float)cos(angle) + position.x, range*(float)sin(angle) + position.y, 0.0f);  
        }
      
        glVertex3f(position.x+range, position.y, 0.0f);

        glEnd();

	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

	return 1;
}



All's well so far, yes?

        glBlendFunc(GL_DST_ALPHA, GL_ONE);
	glEnable(GL_BLEND);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);

	glColor4f(0.3f, 1.0f, 0.3f, 0.0f);

	glBegin(GL_QUADS);
		glVertex2f( 512, 512 );
		glVertex2f( 1024, 512 );
		glVertex2f( 1024, 1024 );
		glVertex2f( 512, 1024 );
	glEnd();



This is just a stand in for my real geometry, but I figure that it's best to test with something simple. Yes, the coordinates overlap the lights radius, so it should be affected. Yet.... it shows up perfectly normal, not a whit of difference made by the alpha buffer. So why is that? Am I missing something massively obvious? Does anyone have any insight as to why this isn't working for me? Thanks in advance for any advice! [Edited by - Toji on June 15, 2005 9:21:43 AM]
// The user formerly known as Tojiro67445, formerly known as Toji [smile]
Advertisement
Okay, I'm usually not one for bumping my own posts, but I'm seriously lost on this one guys. I've been working at it and STILL haven't made any progress, and I really don't have any other insights to add.

Anyone out there with any suggestions? Please?
// The user formerly known as Tojiro67445, formerly known as Toji [smile]
Don't know if you've tried this, and if this is it, but try changing your blendFunc to glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA).

if you have the dest at GL_ONE, then it will keep whatever color is already there and add to it. Of course if it's already black, then you're fine. Looks like you're starting out with green, so as long as you're not drawing to a white background, it should at least change the green channel. You don't mention your ClearColor anywhere.

Also, I just realized, do you have depth test enabled? If you do, then your colors won't draw over your light because that will have filled the depth buffer.

[Edited by - renderer on June 14, 2005 1:37:32 PM]
Just tested your code, and it works fine as long as you don't have depth test on.

Heh, thanks for the help, but I've already got it worked out. All the gory details Here if you're interested. Thanks for the help, though. I was really feeling lost there.

The long and the short of it is that different cards seem to require different format descriptions. ATI cards, for example, seem to assume that you always want an alpha buffer, whereas Nvidia cards require you to explicitly state that you want one. I ended up figuring this out when my program worked on my work computer, but not my home.

A few other notes: I am using depth testing for early z-out and correct depth sorting, but I'm controlling the states very carefully. My current order of operations:

Enable Depth Testing/Writing, Disable Blending
-Initial depth/ambient pass.
Disable Depth Writing
-For each light:
Disable Depth Testing/Color writing.
-Clear the Alpha buffer
-Render the lighting information to the alpha buffer
Enable Depth Testing
-Render Shadow Hulls
Enable Blending/Color Writing, Disable Alpha Writing
-Render All Geometry visible from this light.
Render the rest of the scene normally.

A few warnings I'd like to put out to people wanting to use this method. It's a great effect, but the fillrate requirements are HUGE. You're pretty much writing to each pixle on the screen an absolute mimimum of once per-light just for the alpha clearing pass plus once more for the ambient pass. On average you'll proably be redrawing the entire screen maybe 7-8 times for 3-4 visible lights.

Also, the soft shadowing portion of the code is anything but trivial. I'll post my actual code for it once I've completed it (getting close!) but it requires a lot of careful state-setting that's not covered in the article.

Not trying to discourge anyone here, because I love the effect itself, just a few things to be aware of!
// The user formerly known as Tojiro67445, formerly known as Toji [smile]
Glad you got it working, looks rather nice. :)

Quote:Original post by Toji
A few warnings I'd like to put out to people wanting to use this method. It's a great effect, but the fillrate requirements are HUGE. You're pretty much writing to each pixle on the screen an absolute mimimum of once per-light just for the alpha clearing pass plus once more for the ambient pass. On average you'll proably be redrawing the entire screen maybe 7-8 times for 3-4 visible lights.

Yeah, the fillrate needed is pretty heavy. Having a fairly bright ambient (or maybe whole-world directional) would reduce the number of lights some. I mentioned this in the comments thread for the article, but you can get *big* speedups by using scissor testing around the light bounds.
Wow, the man himself! Thanks for the compliment!

I have a question if you don't mind: in your code what blending options do you use when rendering the shadow fins? I've tried a myriad of combinations, but have yet to get something that looks completely "right". I think that part of this is a bug in my penumbra position generation, but I'm certain that part of it is simply the blending itself.
Strangely enough I've found that glBlendFunc(GL_ZERO, GL_SRC_ALPHA) seems to give me the best results thus far.
// The user formerly known as Tojiro67445, formerly known as Toji [smile]
Shadow fins should be using the same blending func as the shadow hulls. So since you're basically masking off areas you need to multiply the shadow geometry alpha by that already in the framebuffer. So glBlendFunc(GL_ZERO, GL_SRC_ALPHA) should IIRC be the correct function to use. The only difference being that hulls always have an alpha of 0 (fully shadowed) whereas the fins will have a varying alpha for the fade out.

This topic is closed to new replies.

Advertisement