Hey,

I'm having an issue with a normal mapping test of mine. It actually does work, however there is a little side effect that I've been trying to figure out. I understand why it happens, but I am still lost trying to figure out a logical method to stop it outside of multiplying the end result colour by the light.z (normalized distance from the lit surface).

Here is a picture I whipped up to show you the problem I am having with the code.



The cube on the left has the light source lighting surface A and B, but surface C should not be lit because the light source is behind the surface. But because the light vector doesn't scale the x and y components based on the distance to the surface (light.z) the surface will still light the x and y directions. I'm new to normal mapping and so far I understand the general concepts. It's just the subtleties that I'm trying to get accustomed to.

Here is the source code for my shader (at least the relevant parts)



Maybe someone on the XNA forums can pick up something I didn't see.

Thanks for your help.

Not sure if it is your complete issue, but I believe when you get the reflection vector, you want to use the negative of your lightdir.  That is, you want to know where something coming from your light would reflect.   See rizman's clarification in this post http://forums.xna.com/forums/p/26722/146635.aspx#146635

Best,
Byron

Your normal map directions sampled from the texture are probably in local coordinates for the surface, while your light direction is in world space coordinates.  You need to transform the local normal map coordinates into world space before you use them for lighting calculations.

Edit: never mind, I missed the light direction transformation in your vertex shader.

Attempt #2:

Try doing this:

if ( light.Z > 0.0 )
   output.Colour = diffuse + specular;
else
   output.Colour = diffuse;

That will cut out the specular reflection for surfaces that should be self-shadowed by the light.

Sigil has a point i hadn't considered.

Try changing these these lines

float3 refVec   = reflect(light, normal);                                   // light reflection vector
38 float3 refVec = reflect( -light,normal);  float diffuseIntensity  = saturate(dot(light, normal));
40 float specularIntensity = max(dot(refVec, eye), 0);
41Float specularIntensity = max(dot(refVec,eye),0) * saturate(20*diffuseIntensity);

There are cases where the normal points away from the light, but the reflection vector points to the eye, but you shouldn't see anything because the face is away from the light.  Putting the saturate(20*diffuseIntensity) will make sure that you don't get reflections to the eye when the object is facing away.

Best,
Byron

I was aware about the need to change the light vector when reflecting. At first glance, it looked better without the negation but looking at the specular intensity on the cube it appears negating it was correct .. just not as appealing. hehe :P

As for the specular intensity problem, it isn't a specular intensity problem. The problem effects both diffuseintensity and specularintensity. And the main reason why it occurs is this.

set l light(lx, ly, -0.5); // a light behind the surface
set n normal(nx, ny, 0.5); // a normal coming off the surface

now, take in to account that a light source with a l.z value < 0 is behind the surface it should not be lit. However.
l dot n
lx*nx + ly*ny + (-0.5*0.5)
= lx*nx + ly*ny - 0.25

now unless that side of the equation adds up to 0 for all l.z < 0 then you're going to see something through both the diffuse and specular components on the lit face or not.

lets assume that the light vector for l.y and the normal vector for n.y are 0 to eliminate it from the dot product.

l.x*n.x - 0.25

now since the light are shifted in to tangent space as it approaches l.x = 0 it's decreasing and then becomes negative the second half of the rotation around the surface.

Which wound mean that any normal vectors in the negative x direction wouldn't be eliminated but they would if n.x > 0 through (max(0, (negative * positive = negative))).

The problem I'm having is that the examples I see for normal mapping don't seem to correct this, but work correctly. Making a quick fix is easy, understanding why and solving it isn't. If I can't figure that out, then I haven't fully understood the concept. :P