source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/OgreDemos/media/MoriaScene/Troll/Characters.hlsl @ 3255

//#define VARIANCE_SHADOW_MAPPING

#define MAX_LIGHT 2

#include "MoriaSceneillum.hlsl"

uniform sampler2D colorTexture : register(s0);
uniform sampler2D normalMap : register(s1);
uniform samplerCUBE ShadowMap1Point : register(s2);
uniform samplerCUBE ShadowMap2Point : register(s3);
uniform samplerCUBE colorEnvMap : register(s4);
uniform samplerCUBE hiColorEnvMap : register(s5);

uniform float4x4 WorldViewProj;
uniform float4x4 World;
uniform float4x4 WorldI;

uniform float3 wCamPos;

uniform float4 wLightPos1;
uniform float4 wLightPos2;
uniform float4 lightRange1;
uniform float4 lightRange2;
uniform float lightPower1;
uniform float lightPower2;
uniform float4 lightColor1;
float4 lightColor2 = 0;
                        
uniform float4x4 LightView1;
uniform float4x4 LightView2;
uniform float lightFarPlane1;
uniform float lightFarPlane2;

uniform float specularity;
uniform float4 specularColor;
uniform float4 diffColor;


struct CHARACTER_VSOUT
{
    float4 hPos : POSITION;
    float2 texCoord       : TEXCOORD0;
    float3 wView          : TEXCOORD1;
    float3 wTangent       : TEXCOORD2;
    float3 wBinormal      : TEXCOORD3;
    float3 wNormal        : TEXCOORD4;
    float3 wPos           : TEXCOORD5;  
};

CHARACTER_VSOUT CharacterBase_VS(float4 position :POSITION,
                                        float3 normal :NORMAL,
                                        float2 texCoord : TEXCOORD0,
                                        float3 tangent   : TEXCOORD1)
{
    CHARACTER_VSOUT OUT = (CHARACTER_VSOUT) 0;
    
    OUT.texCoord = texCoord;    
        
    OUT.hPos = mul(WorldViewProj, position);
    OUT.wPos = mul(World, position);
    
    OUT.wView = wCamPos - OUT.wPos;
    
    OUT.wTangent = normalize(mul(float4(tangent, 1),WorldI)).xyz;
    OUT.wNormal = normalize(mul(float4(normal, 1),WorldI)).xyz;     
    OUT.wBinormal = cross(OUT.wTangent, OUT.wNormal).xyz;       
        
    return OUT;
}

float4 CharacterBase_PS(CHARACTER_VSOUT IN, uniform float3 lastCenter, uniform float type):COLOR0
{   
    float4 Color = 0;
    float3 N = IN.wNormal;
    if(dot(IN.wBinormal, IN.wBinormal) != 0 )
     N = NormalMap(IN.wTangent, IN.wBinormal, IN.wNormal, IN.texCoord, normalMap);
    //    N = ParallaxMap(IN.wTangent, IN.wBinormal, IN.wNormal, IN.wView, IN.texCoord, normalMap);

    N = normalize(N);
     
    float dist = length(IN.wView);
    float3 V = IN.wView / dist;
    // read textures
    float4 diffuseColor = tex2D(colorTexture, IN.texCoord);
    
//----------------------------------------------------------------------------------------------------------------
//light1        
    //light dir
    float3 L;
    float4 col;
    float3 lightCPos;
    float shadow;

    if( dot(lightRange1, lightRange1) != 0)
    {
        L = wLightPos1.xyz - IN.wPos * wLightPos1.w;
        //illumination
        col = Illumination(N, L, V, lightColor1 * lightPower1, lightRange1, diffuseColor*diffColor, specularity, specularColor);
        //shadowing 
        lightCPos = mul(LightView1, float4(IN.wPos, 1)).xyz;
        shadow = shadowPoint(ShadowMap1Point, lightCPos, lightFarPlane1);
        //shadow = 1;
        Color += col * shadow;  
        
        //Color = col;
    }

    //----------------------------------------------------------------------------------------------------------------
    //light2            
    if( dot(lightRange2, lightRange2) != 0 )
    {
        //light dir
        L = wLightPos2.xyz - IN.wPos * wLightPos2.w;
        //illumination
        col = Illumination(N, L, V, lightColor2 * lightPower2, lightRange2, diffuseColor*diffColor, specularity, specularColor);
        //shadowing 
        lightCPos = mul(LightView2, float4(IN.wPos, 1)).xyz;
        shadow = shadowPoint(ShadowMap2Point, lightCPos, lightFarPlane2);
        Color += col * shadow;  
    }
    
    float4 indirect = 0;
    float reflectivity = 0.5;
    
    if(type == 0)
    {
        indirect = diffuseColor * diffuseIndirect(colorEnvMap, colorEnvMap, N, IN.wPos - lastCenter, V);
        Color = Color + indirect;
    }
    else if(type == 1)
    {
        indirect = readCubeMap(hiColorEnvMap, reflect(-V,N));
        Color = Color * (1-reflectivity) + reflectivity * /*diffuseColor **/ indirect;
    }
    else if(type == 2)
    {
        indirect = glossyIndirect(colorEnvMap, colorEnvMap, N, IN.wPos - lastCenter, -V);
        Color = Color * (1-reflectivity) + reflectivity * /*diffuseColor **/ indirect;
    }
    
    
    Color.a = dist;
    
    //return Color * 0.000000001 + N.xyzz;
    //return dot(N,L);
    return Color;
}