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

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 emmisive,
                         float3 lightDir)
{
        /*
        float4 lightDir2 = float4(-0.5f, 0.5f, 0.4f, 0.0f);
        float3 light2 = normalize(lightDir2.xyz);
        float diffuseLight2 = saturate(dot(normal, light2));
*/
        // diffuse intensity
        const float angle = saturate(dot(normal, lightDir)); 
        
        float4 lightDiffuse = glstate.light[0].diffuse;
        float4 diffuse = angle * lightDiffuse;

        // global ambient
        const float4 ambient = glstate.light[0].ambient;
        
        //return (saturate(((ambient + diffuse))) * (1.0f - emmisive) + emmisive) * color;
        return saturate((((ambient + diffuse)) * (1.0f - emmisive) + emmisive) * color);
}



/** The mrt shader for standard rendering
*/
pixel main(fragment IN, 
                   uniform sampler2D colors,
                   uniform sampler2D positions,
                   uniform sampler2D normals,
                   uniform float3 lightDir
                   )
{
        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, lightDir);
        
        OUT.color = col;
        OUT.color.w = color.w;

        return OUT;
}


float CalcShadowTerm(fragment IN,
                                         uniform sampler2D shadowMap,
                                         uniform float w,
                                         uniform float2 lightSpacePos,
                                         uniform float depth,
                                         uniform float2 samples[NUM_SAMPLES],
                                         uniform sampler2D noiseTexture
                                         )
{
        //float shadowDepth = tex2D(shadowMap, lightSpacePos).x;
        //return step(depth, shadowDepth);

        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;
}


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],
                                  uniform float3 lightDir
                                  )
{
        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);
        
        // hack: an emmisive color term
        float emmisive = norm.w;

        // diffuse intensity
        const float angle = saturate(dot(normal, lightDir)); 
        //float4 lightDiffuse = float4(1.0f, 1.0f, 0.9f, 1.0f);
        const float4 lightDiffuse = glstate.light[0].diffuse;
        //float4(1.0f, 1.0f, 0.9f, 1.0f);

        float4 diffuse = lightDiffuse * angle;

        // calc diffuse illumination + shadow term
        if ((emmisive < 0.95f) // hack: prevent shadowing the sky       
                && (angle > 1e-3f) // shadow only if diffuse color has some minimum intensity
                )
        {
                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;
        const float4 ambient = glstate.light[0].ambient;
        
        // base lighting
        OUT.color = (emmisive < 0.95) ? (ambient + diffuse) * color : color;

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

        return OUT;
}