source: GTP/trunk/App/Demos/Illum/IBRBillboardCloudTrees/OGRE/IBRTreesOGRE/media/general/f_lighting_indirect_texture_mapping.cg.bak @ 1493

// Shadow map always comes in texture unit 0,
// so we have to decal all other textures if any...

  sampler2D indirectTexture : TEXUNIT0;
  sampler2D sourceTexture : TEXUNIT1;
  sampler2D visibilityTexture : TEXUNIT2;


struct Vertex
{
  float4 position       : POSITION;     // Fragment's position in screen-space
  float2 texCoord       : TEXCOORD0;    // Fragment's texture coordinates
  float2 subTexCoord    : TEXCOORD1;    // Fragment's texture coordinates
  float3 normal         : TEXCOORD2;    // Fragment's normal in eye-space
  float3 halfVector     : TEXCOORD3;    // Fragment's half angle vector in eye-space
  float3 lightVector    : TEXCOORD4;    // Fragment's light vector in eye-space
  float4 wposition      : TEXCOORD5;    // Vertex position in world-space
};

struct Fragment
{
    float4 color  : COLOR0;
};

Fragment main(Vertex p_In,
              uniform float4 p_LightDiffuse,        // Light diffuse component
              uniform float  p_LightPower,          // Light power
              uniform float4 p_Diffuse,             // Material diffuse component
              uniform float4 p_LightSpecular,       // Light specular component
              uniform float4 p_Specular,            // Material specular component + specular exponent
              uniform float4 p_Ambient,
              uniform float epsilonX,
              uniform float epsilonY,
              uniform float sourceTextureSize,
              uniform float sqrtNumSamples,
              uniform float greyRange,
              uniform float absGreyMin
              )
{
    Fragment l_Out;

   l_Out.color = float4(0.0, 0.0, 0.0, 0.0);    
   float2 epsilon = float2(epsilonX, epsilonY);  
   float4 value = tex2D(indirectTexture, p_In.subTexCoord).xyzw;
   float2 coords = p_In.texCoord - ( value.xy - epsilon );

   if (value.w != 0.0) 
   {    
            float2 unifcoord;
            float2 scale;
            unifcoord = (p_In.texCoord - value.xy) * float2(sourceTextureSize, sourceTextureSize); 
            //scale = coords * float2(sourceTextureSize, sourceTextureSize) / float2(sqrtNumSamples, sqrtNumSamples);
            //float2 newcoord = float2(1.0, 1.0) - value.zw + scale;
            //float4 diffuseColor = tex2D(sourceTexture, newcoord).xyzw;
            float4 diffuseColor = tex2D(sourceTexture, unifcoord  / float2(sqrtNumSamples, sqrtNumSamples) - epsilon).xyzw;

            // Normalized normal.
            float3 l_Normal = normalize(p_In.normal);

            // Normalized light vector.
            float3 l_LightVector = normalize(p_In.lightVector);
            
            // Normalized half angle vector.
            float3 l_HalfVector = normalize(p_In.halfVector);
            
            // Ambient component
            //------------------
            float3 ambientColor = float3(p_Ambient.xyz); 
            if (diffuseColor.w != 0.0)
            {
                float4 visibility = tex2D(visibilityTexture, p_In.subTexCoord).xyzw;
                //greyRange = greyRange - 0.20;
                visibility.xyzw = (visibility.xyzw * float4(greyRange, greyRange, greyRange, greyRange)) - float4(absGreyMin, absGreyMin, absGreyMin, absGreyMin);
                float e = lerp(visibility.x, visibility.y, unifcoord.x);
                float f = lerp(visibility.w, visibility.z, unifcoord.x);
                float g = clamp(lerp(e, f, unifcoord.y), 0.3, 1.0);
                ambientColor *=  float3(g, g, g);
            }       
            
            l_Out.color.rgb = (ambientColor * diffuseColor.rgb);

            // Diffuse component
            // -----------------

            // Angle between normal and light vector
            float l_CosNL = saturate(dot(l_Normal, l_LightVector)) + saturate(-dot(l_Normal, l_LightVector));

            // No light can reach back surfaces...
            //if (l_CosNL == 0)
            //    discard;
            
            l_Out.color.rgb += (p_Diffuse.rgb * diffuseColor.rgb) * p_LightDiffuse.rgb * l_CosNL;
            
            // Specular component
            // ------------------

            // Apply cosine power distribution around mirror direction
            float l_CosNH = saturate(dot(l_Normal, l_HalfVector)) + saturate(-dot(l_Normal, l_HalfVector));
                
            float l_SpecularPower = pow(l_CosNH, p_Specular.a);
            
            float3 l_Specular = (p_Specular.rgb * diffuseColor.rgb) * p_LightSpecular.rgb * l_SpecularPower;

            // Add specular component
            l_Out.color.rgb += l_Specular.rgb;

            // Modulate by light incoming power
            l_Out.color.rgb *= p_LightPower;

            l_Out.color.a = diffuseColor.a;
    }

    return l_Out;
}