// Calculate the diffuse term:
float DiffuseFactor = pow ( ( 1.0f + dot(-vecSunDir.xyz, InNormal) ) * 0.5f, DiffuseGradient ); 
float3 texColor = texSample.rgb * lerp ( vecAmbient.rgb, vecSunColor.rgb, DiffuseFactor );

// Calculate the speculate component: 
float3 sunDirReflexion = reflect ( vecSunDir.xyz, InNormal );
float3 Specular =  ( vecSunColor.rgb - texColor ) * pow(saturate(dot(sunDirReflexion, InViewDir)), SpecularPower ) * texSample.a;
texColor += Specular * SpecularIntensity;

// Calculate the enviroment reflection term 
float3 viewDirReflexion = reflect ( -InViewDir.xyz, InNormal );
float3 envSample = texCUBE ( sEnv, viewDirReflexion ).rgb;
texColor = lerp ( texColor, texSample.rgb*envSample, texSample.a );

float3 doDiffuse ( float3 inNormal )
{
	float DiffuseFactor = pow ( ( 1.0f + dot(-vecSunDir.xyz, InNormal) ) * 0.5f, DiffuseGradient ); 
	return lerp ( vecAmbient.rgb, vecSunColor.rgb, DiffuseFactor );
}
...
float3 texColor = texSample.rgb * doDiffuse ( inNormal );

void SpecularVS(in float4 InPos		: POSITION,
				in float3 InNormal	: NORMAL,
				in float2 InTex		: TEXCOORD0,
				in float4 InTangent	: TEXCOORD2,
				
				out float4 OutPos	: POSITION,
				out float2 OutTex	: TEXCOORD0,
				out float3 OutNormal: TEXCOORD1,
				out float3 OutViewDir: TEXCOORD2,
				out float3 OutSunDir: TEXCOORD3,
				out float3 OutViewDir2: TEXCOORD4)
{
	
	OutPos = mul(InPos, matWorldViewProj); // Transform the vertex from object space to clip space:


//////////--------------------------- Having these 2 uncommented gives smooth cubemap reflections

//	OutNormal = normalize(mul(InNormal,matWorld)); 	// Transform the normal from object space to world space:
//	OutViewDir = vecViewPos - mul(InPos, matWorld); // Calculate a vector from the vertex to the view:


/////////////-----------------Normal Mapping segment

	// Compute 3x3 matrix to transform from world space to tangent space:
	matTangent[0] = mul(InTangent.xyz, matWorld);
	matTangent[1] = mul(cross(InTangent.xyz,InNormal)*InTangent.w, matWorld);
	matTangent[2] = mul(InNormal, matWorld);

	/////////////-----------

//	---------------------------------------------------------------------------OutNormal = normalize(mul(matTangent,matWorld));

//	OutNormal = normalize(mul(InNormal,matWorld))	
	OutViewDir = normalize(mul(matTangent, vecViewPos - mul(InPos, matWorld))); 	// Calculate the view direction vector in tangent space:

	
	//////
	
	OutSunDir = normalize(mul(matTangent, -vecSunDir)); // Calculate the light direction vector in tangent space:

	//------------------

	OutTex = InTex; // Pass the texture coordinate to the pixel shader:

	
}

void SpecularVS( 
  in float4 InPos: POSITION, 
  in float3 InNormal: NORMAL,
  in float2 InTex: TEXCOORD0, 
  in float4 InTangent: TEXCOORD2, 
  out float4 OutPos: POSITION, 
  out float2 OutTex: TEXCOORD0, 
  out float3 OutNormal: TEXCOORD1, 
  out float3 OutTangent: TEXCOORD2, 
  out float3 OutViewDir: TEXCOORD3) 
{ 
// Transform the vertex from object space to clip space: 
  OutPos = mul(InPos, matWorldViewProj); 
// Transform the normal from object space to world space: 
  OutNormal = normalize(mul(InNormal, matWorld));
// Transform the tangent from object space to world space: 
  OutTangent = mul( InTangent.xyz, matWorld );
// Pass the texture coordinate to the pixel shader: 
  OutTex = InTex; 
// Calculate a vector from the vertex to the view: 
  OutViewDir = vecViewPos - mul(InPos, matWorld); 
}

// Read the normal from the normal map and convert from [0..1] to [-1..1] range 
float3 TSNormal = normalize ( ( NormalSample.rgb * 2.0f ) - 1.0f ); 
// Transform tangent space normal to world space
InNormal = normalize(InNormal); 
InTangent = normalize(InTangent); 
float3 BumpNormal = TSNormal.z * inNormal + TSNormal.x * inTangent + TSNormal.y * cross ( InNormal, InTangent );
...