Sign in to follow this  
noatom

Why normalize it?

Recommended Posts

Ok,I'm rereading the Introduction to 3D Game Programming with Dx10,and I'm at the Lightning chapter.

Here's the HLSL code:

[source lang="cpp"]//=============================================================================
// lighthelper.fx by Frank Luna (C) 2008 All Rights Reserved.
//
// Structures and functions for lighting calculations.
//=============================================================================


struct Light
{
float3 pos;
float3 dir;
float4 ambient;
float4 diffuse;
float4 spec;
float3 att;
float spotPower;
float range;
};

struct SurfaceInfo
{
float3 pos;
float3 normal;
float4 diffuse;
float4 spec;
};

float3 ParallelLight(SurfaceInfo v, Light L, float3 eyePos)
{
float3 litColor = float3(0.0f, 0.0f, 0.0f);

// The light vector aims opposite the direction the light rays travel.
float3 lightVec = -L.dir;

// Add the ambient term.
litColor += v.diffuse * L.ambient;

// Add diffuse and specular term, provided the surface is in
// the line of site of the light.

float diffuseFactor = dot(lightVec, v.normal);
[branch]
if( diffuseFactor > 0.0f )
{
float specPower = max(v.spec.a, 1.0f);
float3 toEye = normalize(eyePos - v.pos);
float3 R = reflect(-lightVec, v.normal);
float specFactor = pow(max(dot(R, toEye), 0.0f), specPower);

// diffuse and specular terms
litColor += diffuseFactor * v.diffuse * L.diffuse;
litColor += specFactor * v.spec * L.spec;
}

return litColor;
}

float3 PointLight(SurfaceInfo v, Light L, float3 eyePos)
{
float3 litColor = float3(0.0f, 0.0f, 0.0f);

// The vector from the surface to the light.
float3 lightVec = L.pos - v.pos;

// The distance from surface to light.
float d = length(lightVec);

if( d > L.range )
return float3(0.0f, 0.0f, 0.0f);

// Normalize the light vector.
lightVec /= d;

// Add the ambient light term.
litColor += v.diffuse * L.ambient;

// Add diffuse and specular term, provided the surface is in
// the line of site of the light.

float diffuseFactor = dot(lightVec, v.normal);
[branch]
if( diffuseFactor > 0.0f )
{
float specPower = max(v.spec.a, 1.0f);
float3 toEye = normalize(eyePos - v.pos);
float3 R = reflect(-lightVec, v.normal);
float specFactor = pow(max(dot(R, toEye), 0.0f), specPower);

// diffuse and specular terms
litColor += diffuseFactor * v.diffuse * L.diffuse;
litColor += specFactor * v.spec * L.spec;
}

// attenuate
return litColor / dot(L.att, float3(1.0f, d, d*d));
}

float3 Spotlight(SurfaceInfo v, Light L, float3 eyePos)
{
float3 litColor = PointLight(v, L, eyePos);

// The vector from the surface to the light.
float3 lightVec = normalize(L.pos - v.pos);

float s = pow(max(dot(-lightVec, L.dir), 0.0f), L.spotPower);

// Scale color by spotlight factor.
return litColor*s;
}


[/source]
note SurfaceInfo is the vertex that is not getting his color computed

As you can see there are 3 types of light defined above.But to create the spotlight,it creates a pointlight and then it needs to actually make that pointlight a spotlight,the thing is,I don't understand why on this line:

float3 lightVec = normalize(L.pos - v.pos)

it uses normalize?Why use normalize? Wouldn't it be the same thing without normalize?!

Share this post


Link to post
Share on other sites
From the mathematical point of view it is not the same. L.pos - v.pos is calculating the vector from v.pos to L.pos so you end up with a vector which has a length that is the distance between those two points. Normalizing it brings it to the length of one. So as jeffery said the dotproduct in the spotlight factor will be scaled and will have a different value.

Share this post


Link to post
Share on other sites
When you normalize the light vector and dot it with the surface normal of a poly, you get the angle of between the light and surface which determines the intensity of the light. If the light vector wasn't unit length, you'd the the light vector projected along the surface normal, which isn't the same.

Share this post


Link to post
Share on other sites
People above pretty much nailed it.

Say L.pos = {10, 10, 10} & V.pos = {5, 5, 5}
L.pos - V.pos = {5, 5, 5}

The light vector is a direction, it just points in a certain direction, hence it should have no length, so you normalize it... and it becomes a unit directional vector {1, 1, 1}. Now you can do the dot product for your lighting without it being over scaled.
Further more, the dot product requires both vectors to be unit vectors to acquire the cosine angle between them.

Remember that when you calculate a "directional vector", you will most of the time want it normalized.

For the point light, you can see that it isn't normalized right away since the equation needs the length from the light position to the vector position to validate its range first. If it does pass, it just divides by the distance to normalize. This is done for efficiency reasons since the normalize function would need to recalculate the length of the vector anyways.

Just to be clear: normalized V = V / length(V).

Also, due to interpolation done by the GPU from the vertex shader to pixel shader, you will need to re-normalize your vectors in the pixel shader.

It is rough to get used to the linear algebra required for 3d graphics. But once you understand the general idea of what each function does visually, you won't really need to remember the exact formulas to do what you envision.

Cheers. Edited by french_hustler

Share this post


Link to post
Share on other sites
[quote name='french_hustler' timestamp='1344533495' post='4967851']
and it becomes a unit directional vector {1, 1, 1}
[/quote]

Sorry to be nitpicky but that should be {1/sqrt(3), 1/sqrt(3), 1/sqrt(3)} [img]http://public.gamedev.net//public/style_emoticons/default/wink.png[/img]

Share this post


Link to post
Share on other sites
One last question,is it needed that at least 1 vectorin the dot product is normalized? If you look above in the sourcecode you will see that in every dot product there is one simple vector and a normalized one. Edited by noatom

Share this post


Link to post
Share on other sites
Not just one but every vector. If you look closely you will see that
[code]
float3 lightVec = L.pos - v.pos;

// The distance from surface to light.
float d = length(lightVec);

if( d > L.range )
return float3(0.0f, 0.0f, 0.0f);

// Normalize the light vector.
lightVec /= d;
[/code]

lightVec is actually normalised

Share this post


Link to post
Share on other sites
But at spotlight at the dot product L.dir is not normalized...?! float s = pow(max(dot(-lightVec, L.dir), 0.0f), L.spotPower);

Also on ParallelLight too: float diffuseFactor = dot(lightVec, v.normal); as you can see there lightVec is not normalized.

I don't understand....

Share this post


Link to post
Share on other sites
[quote name='Madhed' timestamp='1344535321' post='4967862']
[quote name='french_hustler' timestamp='1344533495' post='4967851']
and it becomes a unit directional vector {1, 1, 1}
[/quote]

Sorry to be nitpicky but that should be {1/sqrt(3), 1/sqrt(3), 1/sqrt(3)} [img]http://public.gamedev.net//public/style_emoticons/default/wink.png[/img]
[/quote]

What a silly mistake. Thank you for catching that.
Let's write it out so we don't confuse OP.
if V = [5,5,5], its length = sqrt(25+25+25) = sqrt(75)
Normalized(V) = [5/sqrt(75), 5/sqrt(75), 5/sqrt(75)] = [1/sqrt(3), 1/sqrt(3), 1/sqrt(3)]

[quote]
But at spotlight at the dot product L.dir is not normalized...?! float s = pow(max(dot(-lightVec, L.dir), 0.0f), L.spotPower);
Also on ParallelLight too: float diffuseFactor = dot(lightVec, v.normal); as you can see there lightVec is not normalized.
I don't understand....
[/quote]

L.dir is a member of the light. It is set in the C++ side, and it must be normalized there. So the shader assumes it already is normalized (which it should be anyways).

Again, if you want proper cos angle out the dot product, both vectors must be normalized. In your shader, it is assumed that the light direction is already normalized.

Share this post


Link to post
Share on other sites
I'm sorry to say, but you will need to learn at least the basics of linear algebra to understand what's going on there in the pixel shader. On the other hand it's not that complicated.
I'd say if you're confident in programming you will grasp the math pretty easily.

Share this post


Link to post
Share on other sites
[quote name='noatom' timestamp='1344544874' post='4967907']
So the final advice is to normalize every vector that I use in dot product no matter what?
[/quote]
No, there are plenty of cases where you don't want to normalize a vector used in a dot product. It depends on what you're trying to do. In this case you're interested in the angle between the vectors, the dot product of two normalized vectors gives you the cosine of that angle. So in this case, you want both vectors to be normalized. Edited by Mussi

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this