Jump to content

  • Log In with Google      Sign In   
  • Create Account


Why normalize it?


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
12 replies to this topic

#1 noatom   Members   -  Reputation: 769

Like
0Likes
Like

Posted 08 August 2012 - 03:51 PM

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 © 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?!

Sponsor:

#2 jefferytitan   Crossbones+   -  Reputation: 1720

Like
0Likes
Like

Posted 08 August 2012 - 04:10 PM

My bet is that they normalise it so that the dot product in the next line isn't unnecessarily scaled.

#3 quiSHADgho   Members   -  Reputation: 325

Like
1Likes
Like

Posted 08 August 2012 - 04:21 PM

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.

#4 Seabolt   Members   -  Reputation: 632

Like
2Likes
Like

Posted 09 August 2012 - 09:54 AM

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.
Perception is when one imagination clashes with another

#5 french_hustler   Members   -  Reputation: 341

Like
0Likes
Like

Posted 09 August 2012 - 11:31 AM

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, 09 August 2012 - 11:37 AM.


#6 Madhed   Crossbones+   -  Reputation: 2523

Like
1Likes
Like

Posted 09 August 2012 - 12:02 PM

and it becomes a unit directional vector {1, 1, 1}


Sorry to be nitpicky but that should be {1/sqrt(3), 1/sqrt(3), 1/sqrt(3)} Posted Image

#7 noatom   Members   -  Reputation: 769

Like
0Likes
Like

Posted 09 August 2012 - 12:04 PM

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, 09 August 2012 - 12:13 PM.


#8 Madhed   Crossbones+   -  Reputation: 2523

Like
1Likes
Like

Posted 09 August 2012 - 12:30 PM

Not just one but every vector. If you look closely you will see that
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;

lightVec is actually normalised

#9 noatom   Members   -  Reputation: 769

Like
0Likes
Like

Posted 09 August 2012 - 01:18 PM

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....

#10 french_hustler   Members   -  Reputation: 341

Like
1Likes
Like

Posted 09 August 2012 - 02:00 PM


and it becomes a unit directional vector {1, 1, 1}


Sorry to be nitpicky but that should be {1/sqrt(3), 1/sqrt(3), 1/sqrt(3)} Posted Image


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)]

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....


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.

#11 noatom   Members   -  Reputation: 769

Like
0Likes
Like

Posted 09 August 2012 - 02:41 PM

So the final advice is to normalize every vector that I use in dot product no matter what?

#12 Madhed   Crossbones+   -  Reputation: 2523

Like
0Likes
Like

Posted 09 August 2012 - 03:07 PM

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.

#13 Mussi   Crossbones+   -  Reputation: 1707

Like
3Likes
Like

Posted 09 August 2012 - 03:41 PM

So the final advice is to normalize every vector that I use in dot product no matter what?

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, 09 August 2012 - 03:43 PM.





Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS