normalMap Shader

float4 AmbientColor : Ambient
<
    string UIName = "Ambient Color";
> = {0.25f, 0.25f, 0.25f, 1.0f};

float4 DiffuseColor : Diffuse
<
    string UIName = "Diffuse Color";
> = {1.0f, 1.0f, 1.0f, 1.0f};

texture diffuseMap : DiffuseMap
<
    string name = "default_color.dds";
 string UIName = "Diffuse Texture";
    string TextureType = "2D";
>;

texture normalMap : NormalMap
<
    string name = "default_bump_normal.dds";
 string UIName = "Normal Map";
    string TextureType = "2D";
>;

/************** light info **************/

float4 light1Pos : POSITION
<
 string UIName = "Light Position";
 string Object = "PointLight";
 string Space = "World";
 int refID = 0;
> = {100.0f, 100.0f, 100.0f, 0.0f};

float4 light1Color : LIGHTCOLOR
<
 int LightRef = 0;
> = { 1.0f, 1.0f, 1.0f, 0.0f };

/****************************************************/
/********** SAMPLERS ********************************/
/****************************************************/

sampler2D diffuseMapSampler = sampler_state
{
 Texture = <diffuseMap>;
 MinFilter = Linear;
 MagFilter = Linear;
 MipFilter = Anisotropic;
 ADDRESSU = WRAP;
    ADDRESSV = WRAP;
};

sampler2D normalMapSampler = sampler_state
{
 Texture = <normalMap>;
 MinFilter = Linear;
 MagFilter = Linear;
 MipFilter = Anisotropic;
 ADDRESSU = WRAP;
    ADDRESSV = WRAP;
};

/***********************************************/
/*** automatically-tracked "tweakables" ********/
/***********************************************/

float4x4 WorldViewProjection  : WorldViewProjection  < string UIWidget = "None"; >;
float4x4 WorldInverseTranspose  : WorldInverseTranspose < string UIWidget = "None"; >;
float4x4 ViewInverse    : ViewInverse    < string UIWidget = "None"; >;
float4x4 World      : World     < string UIWidget = "None"; >;

/****************************************************/
/********** CG SHADER FUNCTIONS *********************/
/****************************************************/

// input from application
 struct a2v {
 float4 position  : POSITION;
 float2 texCoord  : TEXCOORD0;
 float3 normal  : NORMAL;
 float3 binormal  : BINORMAL;
 float3 tangent  : TANGENT;
};

// output to fragment program
struct v2f {
        float4 position      : POSITION;
  float2 texCoord      : TEXCOORD0;
  float3 lightVec     : TEXCOORD1;
  float3 worldNormal  : TEXCOORD2;
  float3 worldBinormal : TEXCOORD3;
  float3 worldTangent  : TEXCOORD4;
};

/**************************************/
/***** VERTEX SHADER ******************/
/**************************************/

v2f v(a2v In, uniform float4 lightPosition)
{
 v2f Out;                //create the output struct
    Out.worldNormal = mul(In.normal, WorldInverseTranspose).xyz;  //put the normal in world space pass it to the pixel shader
    Out.worldBinormal = mul(In.binormal, WorldInverseTranspose).xyz; //put the binormal in world space pass it to the pixel shader
    Out.worldTangent = mul(In.tangent, WorldInverseTranspose).xyz;  //put the tangent in world space pass it to the pixel shader
    float3 worldSpacePos = mul(In.position, World);      //put the vertex in world space
    Out.lightVec = lightPosition - worldSpacePos;      //create the world space light vector and pass it to the pixel shader
 Out.texCoord.xy = In.texCoord;          //pass the UV coordinates to the pixel shader
    Out.position = mul(In.position, WorldViewProjection);    //put the vertex position in clip space and pass it to the pixel shader
    return Out;
}

/**************************************/
/***** FRAGMENT PROGRAM ***************/
/**************************************/

float4 f(v2f In,uniform float4 lightColor) : COLOR
{
  //fetch the diffuse and normal maps
  float4 ColorTexture = tex2D(diffuseMapSampler, In.texCoord.xy);    //the tex2d function takes the texture sampler and the texture coordinates and returns the texel color at that point
  float3 normal = tex2D(normalMapSampler, In.texCoord).xyz * 2.0 - 1.0;   //the normal must be expanded from 0-1 to -1 to 1

  //create tangent space vectors
  float3 Nn = In.worldNormal;
  float3 Bn = In.worldBinormal;
  float3 Tn = In.worldTangent;
 
 
  //offset world space normal with normal map values
  float3 N = (normal.z * Nn) + (normal.x * Bn) + (normal.y * -Tn);    //we use the values of the normal map to tweek surface normal, tangent, and binormal
  N = normalize(N);                //normalizing the result gives us the new surface normal
 
  //create lighting vectors - view vector and light vector
  float3 L = normalize(In.lightVec.xyz);          //the light vector must be normalized here so all vectors will be normalized
 
  //lighting
 
  //ambient light
  float4 Ambient = AmbientColor * ColorTexture;        //To create the ambient term, we multiply the ambient color and the diffuse texture
 
   
  //diffuse light
  float4 diffuselight = saturate(dot(N,L)) * lightColor;         //To get the diffuse light value we calculate the dot product between the light vector and the normal        
  float4 Diffuse = DiffuseColor * ColorTexture * diffuselight;        //To get the final diffuse color we multiply the diffuse color by the diffuse texture

  return Diffuse + Ambient;
}

/****************************************************/
/********** TECHNIQUES ******************************/
/****************************************************/

technique regular
{
    pass one
    {  
 VertexShader = compile vs_1_1 v(light1Pos);         //here we call the vertex shader function and tell it we want to use VS 1.1 as the profile     
 ZEnable = true;                //this enables sorting based on the Z buffer
 ZWriteEnable = true;              //this writes the depth value to the Z buffer so other objects will sort correctly this this one
 CullMode = CW;                //this enables backface culling.  CW stands for clockwise.  You can change it to CCW, or none if you want.
 AlphaBlendEnable = false;             //This disables transparency.  If you make it true, the alpha value of the final pixel shader color will determine how transparent the surface is.
 PixelShader = compile ps_2_0 f(light1Color);        //here we call the pixel shader function and tell it we want to use the PS 2.0 profile
    }
}