source: GTP/trunk/App/Demos/Illum/Ogre/Media/Station/stationIllum.hlsl @ 2527

#define SPOT_ANGLE 2.093
#define SPOT_FALLOFF 1
#define SHADOW_COLOR float4(0.2,0.2,0.2,1.0)

#ifdef HIGH_QUALITY
        #define SHADOW_BIAS_POINT 0.0001
        #define SHADOW_EPSILON_POINT 0.005
#else
        #define SHADOW_BIAS_POINT 0.002 
#endif

float4 Illumination(float3 N, float3 L, float3 V, float4 lightColor, float4 lightRange, float3 lightDir, float4 diffuseColor, float specularity, float4 specularColor)
{
        float d = length(L);
        L = normalize(L);
                
//#ifdef HIGH_QUALITY

        //Phong-Blinn
        float3 H = normalize(L + V);
        float4 Lighting = lit(dot(N, L), dot(N, H), specularity);
        Lighting = saturate(Lighting);
        
        float lightAngleCos = cos(70.0 / 180.0 * 3.14);
        float falloff = (max(dot(-L, lightDir), 0) - lightAngleCos) / (1.0 - lightAngleCos);
        falloff = pow(saturate(falloff), 2);
        
        return   lightColor * (Lighting.y * diffuseColor + Lighting.z * specularColor) //color
                         / (lightRange.y + d * lightRange.z + d * d * lightRange.w) //attenuation
                         * falloff //spot falloff
                         ;
                         
//#else

//      return  lightColor * diffuseColor * dot(L,N) * pow(max(dot(-L, lightDir),0),9) / (3*d*d);
        
//#endif        
}

float3 NormalMap(float3 tangent, float3 binormal, float3 normal, float2 texCoord, sampler2D normalMap)
{       
        normal = normalize(normal);     
        //return normal;
        float3 mNormal;
        float3 tNormal = tex2D(normalMap, texCoord).rgb;
        //tNormal = float3(0.5,0.5,1.0);
        
    tangent = normalize(tangent);
        binormal = normalize(binormal); 
        float3x3 TangentToModel = float3x3(tangent, binormal, normal );
                
        tNormal.xy = (tNormal.xy *2.0) - 1.0;
        mNormal = normalize( mul( tNormal, TangentToModel ) );
        
    return mNormal;
}

/*
float shadowPoint(samplerCUBE shadowMap, float3 lightCPos, float lightFarPlane)
{
          float light = 1;
          
          float dist = length(lightCPos) / lightFarPlane;
          float4 storedDist = texCUBE(shadowMap, float3(lightCPos.xy, -lightCPos.z));
          dist -= SHADOW_BIAS_POINT;
          float lit_factor = (dist <= storedDist.r);    
                 
          float M1 = storedDist.r;
          float M2 = storedDist.g;
          float v2 = min(max(M2 - M1 * M1, 0.0) +  SHADOW_EPSILON_POINT, 1.0);
          float m_d = M1 - dist;
          float pmax = v2 / (v2 + m_d * m_d);
                                                        
          light = max(lit_factor, pmax);        
                  
          return (SHADOW_COLOR + (1 - SHADOW_COLOR) * light);
}
*/
float shadowMap(sampler2D shadowMap, float4 lightVPos, float3 lightCPos, float lightFarPlane)
{
#ifdef HIGH_QUALITY
        
          float light = 1;
          if(lightVPos.z > 0)
          {
                lightVPos.xyz /= lightVPos.w;
                float d = length(lightVPos.xy);
            if(d <= 1.0)
        {

                  lightVPos.xy = (lightVPos.xy + 1.0) / 2.0;
                  lightVPos.y = 1.0 - lightVPos.y;

                  float dist = length(lightCPos) / lightFarPlane;
                  float4 storedDist = tex2D(shadowMap, lightVPos.xy);
                  dist -= SHADOW_BIAS_POINT;
                  float lit_factor = (dist <= storedDist.r);    
                         
                  float M1 = storedDist.r;
                  float M2 = storedDist.g;
                  float v2 = min(max(M2 - M1 * M1, 0.0) +  SHADOW_EPSILON_POINT, 1.0);
                  float m_d = M1 - dist;
                  float pmax = v2 / (v2 + m_d * m_d);
                                                                
                  light = max(lit_factor, pmax);        
           }
          }
                  
         // return (SHADOW_COLOR + (1 - SHADOW_COLOR) * light);
         return light;
          
#else
          
          lightVPos.xyz /= lightVPos.w;
          lightVPos.xy = (lightVPos.xy + 1.0) / 2.0;
          lightVPos.y = 1.0 - lightVPos.y;
          
          //return max(tex2D(shadowMap, lightVPos.xy).r > lightVPos.z - 0.01, SHADOW_COLOR);
          return max(tex2Dlod(shadowMap, float4(lightVPos.xy,0,0)).r > lightVPos.z - SHADOW_BIAS_POINT, SHADOW_COLOR);
          
          //distance
          //return tex2D(shadowMap, lightVPos.xy).r > length(lightCPos) / lightFarPlane - 0.01;
          //return tex2Dlod(shadowMap, float4(lightVPos.xy,0,1)).r > length(lightCPos) / lightFarPlane - 0.01;
          
#endif
}

uniform float4 prmAtlasTilesHalfPixel;
uniform float allClusterCount; 
uniform float clusterCount;

float4 PathMapIndirect(sampler2D PMTex, sampler2D weightIndexTex, sampler2D weightTex, float2 texAtlas)
{
        int2 prmAtlasTiles = prmAtlasTilesHalfPixel.xy;
        float2 atlasHalfPixel = prmAtlasTilesHalfPixel.zw;
        
        float3 col = 0;
        for(int iCluster = 0; iCluster < 8; iCluster++)
        {
                float2 prmTexPos = float2(
                        (texAtlas.x + (iCluster % prmAtlasTiles.x)) / prmAtlasTiles.x,
                        1.0 - (texAtlas.y + (iCluster / prmAtlasTiles.x)) / prmAtlasTiles.y) + atlasHalfPixel;

        //      float weightIndex = tex2Dlod(weightIndexTex, float4(((float)iCluster + 0.5) / clusterCount, 0.5, 0, 0)).r;
        //      float3 weight = tex2Dlod(weightTex, float4((weightIndex + 0.5)/allClusterCount, 0.5, 0, 0)).rgb;
        //      float3 val = tex2Dlod(PMTex, float4(prmTexPos, 0, 0)).xyz;
                
                float weightIndex = tex2D(weightIndexTex, float2(((float)iCluster + 0.5) / clusterCount, 0.5)).r;
                float3 weight = tex2D(weightTex, float2((weightIndex + 0.5)/allClusterCount, 0.5)).rgb;
                float3 val = tex2D(PMTex, prmTexPos).xyz;
                
                col += val.xyz * weight;                
        }
        
        return float4(col,1);
}

float3 Caustics(samplerCUBE cauMap, samplerCUBE distMap, float3 dir, float attenuation)
{
        float d = length(dir);
        float4 caustics = texCUBE(cauMap, float3(dir.xy, -dir.z));
        //caustics.r *= d < caustics.a;
        caustics *= 1.0 - saturate(d / attenuation);
        
        return caustics.rgb;
}