//--------------------------------------------------------------
// Diffuse and specular shader
// -------------------------------------------------------------
float4x4 matWorldViewProj;
float4x4 matWorld;
float4 vecLightPos[8]; //light position
float4 vecLightColor[8]; //light position
float4 vecViewPos;
float4 vecFog;
float4 vecSkill41;
texture entSkin1; //this is the color map
texture entSkin2; //this is the normal map
texture entSkin3; //this is the Specular map
sampler ColorMapSampler = sampler_state
{
Texture = <entSkin1>;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = wrap;
AddressV = wrap;
};
sampler BumpMapSampler = sampler_state
{
Texture = <entSkin2>;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = wrap;
AddressV = wrap;
};
sampler SpecMapSampler = sampler_state
{
Texture = <entSkin3>;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = wrap;
AddressV = wrap;
};
// -------------------------------------------------------------
// 2.0
// -------------------------------------------------------------
struct VS_OUTPUT0
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light1 : TEXCOORD2;
float Att1 : TEXCOORD3;
float3 Light2 : TEXCOORD4;
float Att2 : TEXCOORD5;
float Fog : FOG;
};
VS_OUTPUT0 VS_PASS0(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD2 )
{
VS_OUTPUT0 Out = (VS_OUTPUT0)0;
Out.Pos = mul(Pos, matWorldViewProj); // transform Position
// compute the 3x3 tranform matrix
// to transform from world space to tangent space
float3x3 worldToTangentSpace;
worldToTangentSpace[0] = mul(Tangent, matWorld);
worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld);
worldToTangentSpace[2] = mul(Normal, matWorld);
Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos;
Out.View = mul(worldToTangentSpace, - Viewer); // V
//light 1
float3 Light1 = PosWorld - vecLightPos[0] ;
Out.Light1.xyz = mul(worldToTangentSpace, -Light1); // L
Out.Att1 = distance(PosWorld,vecLightPos[0])/vecLightPos[0].w; // Point light
//light 2
float3 Light2 = PosWorld - vecLightPos[1] ;
Out.Light2.xyz = mul(worldToTangentSpace, -Light2); // L
Out.Att2 = distance(PosWorld,vecLightPos[1])/vecLightPos[1].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z);
Out.Fog = ofog;
return Out;
}
struct PS_INPUT0
{
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light1 : TEXCOORD2;
float Att1 : TEXCOORD3;
float3 Light2 : TEXCOORD4;
float Att2 : TEXCOORD5;
};
float4 PS_PASS0( PS_INPUT0 psInStruct ):COLOR
{
float4 color = tex2D(ColorMapSampler,psInStruct.Tex); // fetch color map
float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map
float4 gloss = tex2D( SpecMapSampler, psInStruct.Tex );
bumpNormal.b=tex2D(BumpMapSampler, psInStruct.Tex).b;
float3 ViewDir = normalize(psInStruct.View);
//light1
float3 LightDir1 = normalize(psInStruct.Light1);
float4 diff1 = saturate(dot(LightDir1,bumpNormal)); // diffuse component
float3 Reflect1 = normalize(2 * dot(LightDir1, bumpNormal) * bumpNormal - LightDir1); // R
float4 spec1 = saturate(dot(Reflect1, ViewDir))*gloss;
float4 Attenuation1 = saturate(dot(psInStruct.Att1, psInStruct.Att1));
//light2
float3 LightDir2 = normalize(psInStruct.Light2);
float4 diff2 = saturate(dot(LightDir2,bumpNormal)); // diffuse component
float3 Reflect2 = normalize(2 * dot(LightDir2, bumpNormal) * bumpNormal - LightDir2); // R
float4 spec2 = saturate(dot(Reflect2, ViewDir))*gloss;
float4 Attenuation2 = saturate(dot(psInStruct.Att2, psInStruct.Att2));
return
(
(0 * color) + //ambient
((color * (diff1 + vecSkill41) + spec1 * (1 -Attenuation1))*vecLightColor[0])+
((color * (diff2 + vecSkill41) + spec2 * (1 -Attenuation2))*vecLightColor[1])
+ float4(0.0,0.0,0.0,color.a)
);
}
struct VS_OUTPUT1
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light3 : TEXCOORD2;
float Att3 : TEXCOORD3;
float3 Light4 : TEXCOORD4;
float Att4 : TEXCOORD5;
float Fog : FOG;
};
VS_OUTPUT1 VS_PASS1(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD2 )
{
VS_OUTPUT1 Out = (VS_OUTPUT1)0;
Out.Pos = mul(Pos, matWorldViewProj); // transform Position
// compute the 3x3 tranform matrix
// to transform from world space to tangent space
float3x3 worldToTangentSpace;
worldToTangentSpace[0] = mul(Tangent, matWorld);
worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld);
worldToTangentSpace[2] = mul(Normal, matWorld);
Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos;
Out.View = mul(worldToTangentSpace, -Viewer); // V
//light 3
float3 Light3 = PosWorld - vecLightPos[2] ;
Out.Light3.xyz = mul(worldToTangentSpace, -Light3); // L
Out.Att3 = distance(PosWorld,vecLightPos[2])/vecLightPos[2].w; // Point light
//light 4
float3 Light4 = PosWorld - vecLightPos[3] ;
Out.Light4.xyz = mul(worldToTangentSpace, -Light4); // L
Out.Att4 = distance(PosWorld,vecLightPos[3])/vecLightPos[3].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z);
Out.Fog = ofog;
return Out;
}
struct PS_INPUT1
{
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light3 : TEXCOORD2;
float Att3 : TEXCOORD3;
float3 Light4 : TEXCOORD4;
float Att4 : TEXCOORD5;
};
float4 PS_PASS1( PS_INPUT1 psInStruct ):COLOR
{
float4 color = tex2D(ColorMapSampler,psInStruct.Tex); // fetch color map
float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map
float4 gloss = tex2D( SpecMapSampler, psInStruct.Tex );
bumpNormal.b=tex2D(BumpMapSampler, psInStruct.Tex).b;
float3 ViewDir = normalize(psInStruct.View);
//light3
float3 LightDir3 = normalize(psInStruct.Light3);
float4 diff3 = saturate(dot(LightDir3,bumpNormal)); // diffuse component
float3 Reflect3 = normalize(2 * dot(LightDir3, bumpNormal) * bumpNormal - LightDir3); // R
float4 spec3 = saturate(dot(Reflect3, ViewDir))*gloss;
float4 Attenuation3 = saturate(dot(psInStruct.Att3, psInStruct.Att3));
//light4
float3 LightDir4 = normalize(psInStruct.Light4);
float4 diff4 = saturate(dot(LightDir4,bumpNormal)); // diffuse component
float3 Reflect4 = normalize(2 * dot(LightDir4, bumpNormal) * bumpNormal - LightDir4); // R
float4 spec4 = saturate(dot(Reflect4, ViewDir))*gloss;
float4 Attenuation4 = saturate(dot(psInStruct.Att4, psInStruct.Att4));
return
(
((color * diff3 + spec3 * (1 -Attenuation3))*vecLightColor[2])+
((color * diff4 + spec4 * (1 -Attenuation4))*vecLightColor[3])
+ float4(0.0,0.0,0.0,color.a)
);
}
struct VS_OUTPUT2
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light5 : TEXCOORD2;
float Att5 : TEXCOORD3;
float3 Light6 : TEXCOORD4;
float Att6 : TEXCOORD5;
float Fog : FOG;
};
VS_OUTPUT2 VS_PASS2(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD2 )
{
VS_OUTPUT2 Out = (VS_OUTPUT2)0;
Out.Pos = mul(Pos, matWorldViewProj); // transform Position
// compute the 3x3 tranform matrix
// to transform from world space to tangent space
float3x3 worldToTangentSpace;
worldToTangentSpace[0] = mul(Tangent, matWorld);
worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld);
worldToTangentSpace[2] = mul(Normal, matWorld);
Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos;
Out.View = mul(worldToTangentSpace, -Viewer); // V
//light 5
float3 Light5 = PosWorld - vecLightPos[4] ;
Out.Light5.xyz = mul(worldToTangentSpace, -Light5); // L
Out.Att5 = distance(PosWorld,vecLightPos[4])/vecLightPos[4].w; // Point light
//light 6
float3 Light6 = PosWorld - vecLightPos[5] ;
Out.Light6.xyz = mul(worldToTangentSpace, -Light6); // L
Out.Att6 = distance(PosWorld,vecLightPos[5])/vecLightPos[5].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z);
Out.Fog = ofog;
return Out;
}
struct PS_INPUT2
{
float2 Tex : TEXCOORD0;
float3 View : TEXCOORD1;
float3 Light5 : TEXCOORD2;
float Att5 : TEXCOORD3;
float3 Light6 : TEXCOORD4;
float Att6 : TEXCOORD5;
};
float4 PS_PASS2( PS_INPUT2 psInStruct ):COLOR
{
float4 color = tex2D(ColorMapSampler,psInStruct.Tex); // fetch color map
float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map
float4 gloss = tex2D( SpecMapSampler, psInStruct.Tex );
bumpNormal.b=tex2D(BumpMapSampler, psInStruct.Tex).b;
float3 ViewDir = normalize(psInStruct.View);
//light5
float3 LightDir5 = normalize(psInStruct.Light5);
float4 diff5 = saturate(dot(LightDir5,bumpNormal)); // diffuse component
float3 Reflect5 = normalize(2 * dot(LightDir5, bumpNormal) * bumpNormal - LightDir5); // R
float4 spec5 = saturate(dot(Reflect5, ViewDir))*gloss;
float4 Attenuation5 = saturate(dot(psInStruct.Att5, psInStruct.Att5));
//light6
float3 LightDir6 = normalize(psInStruct.Light6);
float4 diff6 = saturate(dot(LightDir6,bumpNormal)); // diffuse component
float3 Reflect6 = normalize(2 * dot(LightDir6, bumpNormal) * bumpNormal - LightDir6); // R
float4 spec6 = saturate(dot(Reflect6, ViewDir))*gloss;
float4 Attenuation6 = saturate(dot(psInStruct.Att6, psInStruct.Att6));
return
(
((color * diff5 + spec5 * (1 -Attenuation5))*vecLightColor[4])+
((color * diff6 + spec6 * (1 -Attenuation6))*vecLightColor[5])
+ float4(0.0,0.0,0.0,color.a)
);
}
// -------------------------------------------------------------
// 1.1
// -------------------------------------------------------------
float3x3 matTangent;
float4x4 matWorldView;
float4 vecSunDir;
float4 DoTransform(float4 Pos)
{
return mul(Pos,matWorldViewProj);
}
float DoFog(float4 Pos)
{
float3 P = mul(Pos,matWorldView); // convert vector to view space to get it's depth (.z)
return saturate((vecFog.y-P.z) * vecFog.z); // apply the linear fog formula
}
float4 DoPos(float4 Pos)
{
return (mul(Pos,matWorld));
}
float3 DoPos(float3 Pos)
{
return (mul(Pos,matWorld));
}
void CreateTangents(float3 inNormal,float3 inTangent)
{
matTangent[0] = DoPos(inTangent);
matTangent[1] = DoPos(cross(inTangent,inNormal)); // binormal
matTangent[2] = DoPos(inNormal);
}
float3 DoTangent(float3 inVector)
{
return normalize(mul(matTangent,inVector));
}
struct out_bump
{
float4 Pos: POSITION;
float Fog: FOG;
float4 Color: COLOR;
float2 Tex: TEXCOORD0;
float2 Bump: TEXCOORD1;
float3 Normal: TEXCOORD2;
float3 Light: TEXCOORD3;
};
out_bump vs_bump( in float4 inPos: POSITION, in float3 inNormal: NORMAL, in float2 inTex: TEXCOORD0, in float3 inTangent: TEXCOORD2)
{
out_bump Out;
Out.Pos = DoTransform(inPos);
Out.Tex = inTex;
Out.Bump = inTex; // different coordinates required for ps_1_1
Out.Color = float4(1.0,1.0,1.0,1.0);
Out.Fog = DoFog(inPos);
CreateTangents(inNormal,inTangent);
float3 N = matTangent[2];
// transform the output values into the 0..1 range
Out.Light = DoTangent(-vecSunDir) * 0.5 + 0.5;
Out.Normal = DoTangent(N) * 0.5 + 0.5;
return Out;
}
float4 ps_bump(out_bump In): COLOR
{
float4 base = tex2D(ColorMapSampler,In.Tex);
float3 bumpNormal = (tex2D(BumpMapSampler,In.Bump)*2) - 1;
bumpNormal.b=tex2D(BumpMapSampler,In.Bump).b;
float diffuse = saturate(dot(In.Light*2 - 1,bumpNormal));
diffuse *= saturate(4 * dot(In.Light*2 - 1,In.Normal*2 - 1));
return base * diffuse;
}
// -------------------------------------------------------------
// techniques//
// -------------------------------------------------------------
// 2.0
technique SpecularNormalMapping_20
{
pass P0
{
alphablendenable=false;
srcblend=zero;
zWriteEnable = true;
alphaTestEnable = true;
// compile shaders
VertexShader = compile vs_2_0 VS_PASS0();
PixelShader = compile ps_2_0 PS_PASS0();
}
}
// 1.1
technique SpecularNormalMapping_11
{
pass P0
{
zWriteEnable = true;
alphaTestEnable = true;
VertexShader = compile vs_1_1 vs_bump();
PixelShader = compile ps_1_1 ps_bump();
}
}
// Fallback; If nothing works
technique fallback { pass one { } }