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

#include "../shaderenv.h"


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


struct pixel
{
        float4 color: COLOR0;
};


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 float3 normal,
                         float3 lightDir)
{
        // 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;
        
        float4 outColor;

        // hack: prevent shading the sky
        if (color.w > 1e19f) outColor = color;
        else outColor = (ambient + diffuse) * color;

        return outColor;
}



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

        float4 norm = tex2D(normals, IN.texCoord);
        float4 color = tex2Dlod(colors, float4(IN.texCoord, 0, 0));
        
        float3 normal = normalize(norm.xyz);
        float4 col = shade(IN, color, normal, lightDir);
        
        OUT.color = col;
        //OUT.color.xyz = normal * 0.5f + 0.5f;
        // store scaled view vector so wie don't have to normalize for e.g., ssao
        OUT.color.w = color.w;// / length(IN.view);
        
        return OUT;
}


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

        float total_d = .0f;
        float total_w = .0f;

        for (int i = 0; i < NUM_PCF_TABS; ++ i) 
        {
                const float2 offset = samples[i];
                const float w = weights[i];

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

                float2 mynoise = tex2D(noiseTexture, IN.texCoord).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 * scale;

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

                total_d += w * step(depth, shadowDepth);
                total_w += w;
        }

        total_d /= (float)total_w;

        return total_d;
}


inline float3 Interpol(float2 w, float3 bl, float3 br, float3 tl, float3 tr)
{
        float3 x1 = lerp(bl, tl, w.y);
        float3 x2 = lerp(br, tr, w.y); 
        float3 v  = lerp(x1, x2, w.x); 

        return v;
}


pixel main_shadow(fragment IN, 
                                  uniform sampler2D colors,
                                  uniform sampler2D positions,
                                  uniform sampler2D normals,               
                                  uniform sampler2D shadowMap,
                                  uniform float4x4 shadowMatrix,
                                  uniform float sampleWidth,
                                  uniform sampler2D noiseTex,
                                  uniform float2 samples[NUM_PCF_TABS],
                                  uniform float weights[NUM_PCF_TABS],
                                  uniform float3 lightDir,
                                  uniform float3 eyePos,
                                  uniform float3 bl,
                                  uniform float3 br,
                                  uniform float3 tl,
                                  uniform float3 tr
                                  )
{
        pixel OUT;

        float4 norm = tex2D(normals, IN.texCoord.xy);
        const float3 normal = normalize(norm.xyz);

        float4 color = tex2Dlod(colors, float4(IN.texCoord, 0, 0));

        /// reconstruct position from the eye space depth
        float3 viewDir = IN.view;
        const float lenView = length(viewDir);
        viewDir /= lenView;

        const float eyeDepth = tex2Dlod(colors, float4(IN.texCoord, 0, 0)).w;

        const float4 worldPos = float4(eyePos - viewDir * eyeDepth, 1);
        
        // diffuse intensity
        const float angle = saturate(dot(normal, lightDir)); 
        const float4 lightDiffuse = glstate.light[0].diffuse;
        
        float4 diffuse = lightDiffuse * angle;

        // hack: prevent shadowing the sky      
        const bool useShading = (color.w < 1e19f);

        // calc diffuse illumination + shadow term
        if (useShading && 
                (angle > 1e-3f) // shadow only if diffuse color has some minimum intensity
                )
        {
                float4 lightSpacePos = mul(shadowMatrix, worldPos);
                lightSpacePos /= lightSpacePos.w;

                float shadowTerm = CalcShadowTerm(IN, shadowMap, sampleWidth, lightSpacePos.xy, lightSpacePos.z, samples, weights, noiseTex);
        
                diffuse *= shadowTerm;
        }

        // light ambient term
        const float4 ambient = glstate.light[0].ambient;
        // compute shading
        OUT.color = useShading ? (ambient + diffuse) * color : color;
        // store scaled view vector from now on so wie don't have to normalize later (e.g., for ssao)
        OUT.color.w = color.w / lenView;

        return OUT;
}

#if 0
/** This shader computes the reprojection and stores reprojected color / depth values
        as well as a boolean that 
*/
pixel Reproject(fragment IN, 
                                uniform sampler2D colors,
                                uniform sampler2D normals)
{
        float4 norm = tex2Dlod(normals, float4(IN.texCoord, 0 ,0));
        const float3 normal = normalize(norm.xyz);

        /// reconstruct position from the eye space depth
        float3 viewDir = IN.view;
        const float eyeDepth = tex2Dlod(colors, float4(IN.texCoord, 0, 0)).w;
        const float3 eyeSpacePos = -viewDir * eyeDepth;
        const float4 worldPos = float4(eyePos + eyeSpacePos, 1.0f);


        ////////////////
        //-- calculcate the current projected posiion (also used for next frame)
        
        float4 currentPos = mul(modelViewProj, worldPos);
        
        const float w = SAMPLE_RADIUS / currentPos.w;
        currentPos /= currentPos.w;
        
        const float precisionScale = 1e-3f;
        const float currentDepth = currentPos.z * precisionScale;

        const float2 ao = ssao(IN, colors, noiseTex, samples, normal, 
                                   eyeSpacePos, w, bl, br, tl, tr, normalize(viewDir));


        /////////////////
        //-- compute temporally smoothing


        // reproject new frame into old one 
        
        // calculate projected depth
        float4 projPos = mul(oldModelViewProj, worldPos);
        projPos /= projPos.w;
        
        // the current depth projected into the old frame
        const float projDepth = projPos.z * precisionScale;
        // fit from unit cube into 0 .. 1
        const float2 tex = projPos.xy * 0.5f + 0.5f;
        // retrieve the sample from the last frame
        float4 oldCol = tex2D(oldTex, tex);

        const float oldDepth = oldCol.z;
        //const float depthDif = 1.0f - projDepth / oldDepth;
        const float depthDif = projDepth - oldDepth;

        //const float oldNumSamples = oldCol.y;
        const float oldWeight = clamp(oldCol.y, 0, temporalCoherence);

        float newWeight;

        // the number of valid samples in this frame
        //const float newNumSamples = ao.y;

        if ((temporalCoherence > 0)
                && (tex.x >= 0.0f) && (tex.x < 1.0f)
                && (tex.y >= 0.0f) && (tex.y < 1.0f)
                && (abs(depthDif) < MIN_DEPTH_DIFF) 
                && (abs(oldCol.x - ao.x) < 0.1f)
                // if visibility changed in the surrounding area we have to recompute
                //&& (oldNumSamples > 0.8f * newNumSamples)
                )
        {
                // increase the weight for convergence
                newWeight = oldWeight + 1.0f;
                OUT.illum_col.x = (ao.x + oldCol.x * oldWeight) / newWeight;
                //if (!(oldNumSamples > ao.y - 1.5f)) newWeight = 0;
        }
        else
        {       
                OUT.illum_col.x = ao.x;
                newWeight = .0f;
        }

        OUT.illum_col.y = newWeight;
        OUT.illum_col.z = currentDepth;

        return OUT;
}

#endif


float4 Output(fragment IN, uniform sampler2D colors): COLOR
{    
        // let bilinear filtering do its work
        return tex2Dlod(colors, float4(IN.texCoord, 0, 0));
}