Hello all,
I’ve been implementing the “Shadow wedge”-algorithm (original paper: http://www.cs.lth.se/home/Tomas_Akenine_Moller/pubs/soft_sig2003.pdf ) for quite some time and got really good results. I’ve used a floating point render target as the Li-Buffer for the hard shadow-pass and also for the wedge-pass.
My problem is how to render the hard shadows efficiently and run on ATI and nVidia cards (so NV_copy_depth_to_color is not an option). What I’ve done so far is sort of simulating the stencil buffer with a fp16 color buffer:
Hardshadow-pass (alternative #1):
-glEnable(GL_CULL_FACE), glFrontFace( GL_CW )
-set blending to additive (glBlendFunc(GL_ONE, GL_ONE))
-set fragment shader constant to +1 (this is returned in result.color and works like glStencilOp(GL_INCR_WRAP_EXT))
-render all shadow volume faces
-glFrontFace( GL_CCW )
-set fragment shader constant to -1 (this is returned in result.color and works like glStencilOp(GL_DECR_WRAP_EXT))
-render all shadow volume faces
This works, but I have to render the shadow volumes twice (which means transform vertices twice). I’ve come up with a different implementation which simulates GL_STENCIL_TEST_TWO_SIDE_EXT:
Hardshadow-pass (alternative #2):
-glDisable(GL_CULL_FACE)
-set blending to additive (glBlendFunc(GL_ONE, GL_ONE))
-provide normals for the shadow volume faces
-use a vertex shader that computes vertexNormal_dot_eyeVector and write +1 or -1 to result.color (should behave like glStencilOp( GL_INCR_WRAP_EXT / GL_DECR_WRAP_EXT ))
-render all shadow volume faces
Here’s my problem: Alternative #2 is not working correctly. Here you can see what I’m talking about:
I’m providing normals for the shadow volume faces and I’m doing this in the vertex shader:
!!ARBvp1.0
ATTRIB v0 = vertex.position;
PARAM WVP[4] = { state.matrix.mvp };
PARAM eye = program.local[0];
PARAM svrt = program.local[1];
PARAM params = { 0, 1, -2, 0 };
#############################################
# output position
DP4 result.position.x, WVP[0], v0;
DP4 result.position.y, WVP[1], v0;
DP4 result.position.z, WVP[2], v0;
DP4 result.position.w, WVP[3], v0;
#############################################
# calc if backface
TEMP res, eyeVec, temp;
SUB eyeVec, eye, v0; # calc eyeVec
DP4 res.x, eyeVec, eyeVec; # Normalize eyeVec (not really neccessary)
RSQ res.y, res.x;
MUL eyeVec, eyeVec, res.y;
DP4 res.x, vertex.normal, eyeVec; # check if front- or backfacing
MUL res.x, res.x, svrt.x; # svrt is Z_FAIL ? multiply by -1, else multiply by 1
SLT res.y, res.x, params.x; # res < 0.0 (Frontfacing means subtractive!) ? res.y = 1.0 : res.y = 0.0
MUL res.x, res.y, params.z; # Frontfacing? res.x = -2.0 : res.x = 0.0;
ADD res.z, params.y, res.x; # Frontfacing? res.z = -1.0 : res.z = 1.0;
MOV result.color, res.z; # output -1 or 1 for color
END
The fragment shader is just passing through the colors from the vertex shader.
What I don’t really get is:
I’m only writing -1 or +1 as output color.
Why am I getting fractional values?
Why is the same (like writing -1 or +1 depending on winding) working in the twopass version?
Any help will be appreciated,
GuentherKrass