source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/deferred.cg @ 2945

struct fragment
{
         // normalized screen position
        float4 pos: WPOS;
        float4 texCoord: TEXCOORD0; 
        float3 view: COLOR0;
};


struct pixel
{
        float4 color: COLOR0;
};

#define NUM_SAMPLES 16


float2 myreflect(float2 pt, float2 n)
{
        // distance to plane
        float d = dot(n, pt);
        // reflect around plane
        float2 rpt = pt - d * 2.0f * n;

        return rpt;
}


/** function for standard deferred shading
*/
float4 shade(fragment IN, 
                         uniform float4 color,
                         uniform float4 position,
                         uniform float3 normal,
                         uniform float amb)
{
        const float4 lightDir = float4(0.8f, -1.0f, 0.7f, 0.0f);
        const float3 light = normalize(lightDir.xyz);
        const float diffuseLight = saturate(dot(normal, light));
        
        /*
        float4 lightDir2 = float4(-0.5f, 0.5f, 0.4f, 0.0f);
        float3 light2 = normalize(lightDir2.xyz);
        float diffuseLight2 = saturate(dot(normal, light2));
*/
        float diffuse = diffuseLight;// + diffuseLight2;

        // global ambient
        const float4 ambient = 0.25f;
        //const float4 ambient = 0.0f;

        return (ambient + diffuse) * color * (1.0f - amb) + amb * color;
}



/** The mrt shader for standard rendering
*/
pixel main(fragment IN, 
                   uniform sampler2D colors,
                   uniform sampler2D positions,
                   uniform sampler2D normals    
                   )
{
        pixel OUT;

        float4 norm = tex2D(normals, IN.texCoord.xy);
        float4 color = tex2Dlod(colors, float4(IN.texCoord.xy, 0, 0));
        float4 position = tex2D(positions, IN.texCoord.xy);

        // an ambient color term
        float amb = norm.w;

        float3 normal = normalize(norm.xyz);

        float4 col = shade(IN, color, position, normal, amb);
        
        //OUT.color = float4(1.0f);
        OUT.color = col;
        OUT.color.w = color.w;

        return OUT;
}


float CalcShadowTerm(fragment IN,
                                         uniform sampler2D shadowMap,
                                         uniform float w,
                                         uniform float2 lightSpacePos,
                                         float depth,
                                         uniform float2 samples[NUM_SAMPLES],
                                         uniform sampler2D noiseTexture
                                         )
{
        float total_d = 0.0;

        for (int i = 0; i < NUM_SAMPLES; ++ i) 
        {
                const float2 offset = samples[i];

#if 1
                ////////////////////
                //-- add random noise: reflect around random normal vector (warning: slow!)

                float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy).xy;
                const float2 offsetTransformed = myreflect(offset, mynoise);
#else
                const float2 offsetTransformed = offset;
#endif
                // weight with projected coordinate to reach similar kernel size for near and far
                float2 texcoord = lightSpacePos + offsetTransformed * w;

                float shadowDepth = tex2D(shadowMap, texcoord).x;

                total_d += step(depth, shadowDepth);
        }

        total_d /= (float)NUM_SAMPLES;

        return total_d;
}


#if 0
/** The mrt shader for standard rendering
*/
pixel main_shadow(fragment IN, 
                                  uniform sampler2D colors,
                                  uniform sampler2D positions,
                                  uniform sampler2D normals,               
                                  uniform sampler2D shadowMap,
                                  uniform float4x4 shadowMatrix,
                                  uniform float maxDepth,
                                  uniform float sampleWidth
                                  )
{
        pixel OUT;

        float4 norm = tex2D(normals, IN.texCoord.xy);
        float4 color = tex2Dlod(colors, float4(IN.texCoord.xy, 0, 0));
        float4 position = tex2D(positions, IN.texCoord.xy);


        // an ambient color term
        float amb = norm.w;

        float3 normal = normalize(norm.xyz);
        float4 col = shade(IN, color, position, normal, amb);
        
        position *= maxDepth;
        position.w = 1.0f;
        
        float4 lightSpacePos = mul(shadowMatrix, position);
        lightSpacePos /= lightSpacePos.w;

        OUT.color = col;

        float shadowDepth[9];

        float w = sampleWidth;

        // pcf sampling using 3 x 3 tab
        shadowDepth[0] = tex2D(shadowMap, lightSpacePos.xy).x;
        
        shadowDepth[1] = tex2D(shadowMap, lightSpacePos.xy + float2( w,  w)).x;
        shadowDepth[2] = tex2D(shadowMap, lightSpacePos.xy + float2( w, -w)).x;
        shadowDepth[3] = tex2D(shadowMap, lightSpacePos.xy + float2(-w, -w)).x;
        shadowDepth[4] = tex2D(shadowMap, lightSpacePos.xy + float2(-w,  w)).x;

        shadowDepth[5] = tex2D(shadowMap, lightSpacePos.xy + float2( w,  0)).x;
        shadowDepth[6] = tex2D(shadowMap, lightSpacePos.xy + float2( 0,  w)).x;
        shadowDepth[7] = tex2D(shadowMap, lightSpacePos.xy + float2(-w,  0)).x;
        shadowDepth[8] = tex2D(shadowMap, lightSpacePos.xy + float2( 0, -w)).x;

        
        float depth = lightSpacePos.z;

        float d = 0.0f;

        for (int i = 0; i < 9; ++ i)
        {
                d += step(shadowDepth[i], depth);
        }

        d /= 9.0f;
        
        if (amb < 0.9f) // hack: prevent shadowing the sky      
        {
                // base lighting
                const float x = 0.4f;
                OUT.color *= x + (1.0f - x) * (1.0f - d);
        }
        
        /*
        // hard shadows
        float shadowDepth = tex2D(shadowMap, lightSpacePos.xy).x;

        if ((amb < 0.9f) && // hack: prevent shadowing the sky  
                (lightSpacePos.z > shadowDepth))
        {
                OUT.color *= 0.1f;
        }*/

        OUT.color.w = color.w;

        return OUT;
}

#else


pixel main_shadow(fragment IN, 
                                  uniform sampler2D colors,
                                  uniform sampler2D positions,
                                  uniform sampler2D normals,               
                                  uniform sampler2D shadowMap,
                                  uniform float4x4 shadowMatrix,
                                  uniform float maxDepth,
                                  uniform float sampleWidth,
                                  uniform sampler2D noiseTexture,
                                  uniform float2 samples[NUM_SAMPLES]
                                  )
{
        pixel OUT;

        float4 norm = tex2D(normals, IN.texCoord.xy);
        float4 color = tex2Dlod(colors, float4(IN.texCoord.xy, 0, 0));
        float4 position = tex2D(positions, IN.texCoord.xy);
        
        const float3 normal = normalize(norm.xyz);
        const float3 lightDir = normalize(float3(0.8f, -1.0f, 0.7f));

        // hack: an emmisive color term
        float emmisive = norm.w;

        // diffuse intensity
        const float angle = saturate(dot(normal, lightDir)); 
        float diffuse = angle;

        // calc diffuse illumination + shadow term
        if ((emmisive < 0.95f) // hack: prevent shadowing the sky       
                && (angle > 1e-3f)
                )
        {
                position *= maxDepth;
                position.w = 1.0f;

                float4 lightSpacePos = mul(shadowMatrix, position);
                lightSpacePos /= lightSpacePos.w;

                float shadowTerm = CalcShadowTerm(IN, shadowMap, sampleWidth, lightSpacePos.xy, lightSpacePos.z, samples, noiseTexture);

                diffuse *= shadowTerm;
        }

        // global ambient
        const float4 ambient = 0.25f;
        
        // base lighting
        OUT.color = (ambient + diffuse) * color * (1.0f - emmisive) + emmisive * color;

        // also write out depth component
        OUT.color.w = color.w;

        return OUT;
}

#endif