source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsao.cg @ 3148

#include "../shaderenv.h"


/******************************************/
/* Filter for combining ssao with image   */
/******************************************/


struct fragment
{
        float2 texCoord: TEXCOORD0; 
        float3 view: TEXCOORD1;
};


struct pixel
{
        float4 illum_col: COLOR0;
};


/** Filter taking into account depth and normal differences, 
   and convergence of a sample  
*/
float DiscontinuityFilter(float2 texCoord,
                                                  float4 ao,
                                                  float4 color,
                                                  uniform sampler2D ssaoTex,
                                                  uniform sampler2D normalsTex,
                                                  uniform sampler2D colorsTex,
                                                  uniform float2 filterOffs[NUM_SSAO_FILTERSAMPLES],
                                                  uniform float filterWeights[NUM_SSAO_FILTERSAMPLES],
                                                  float scale)
{
        float average = .0f;
        float total_w = .0f;

        const float eyeSpaceDepth = color.w;

        const float3 centerNormal = normalize(tex2Dlod(normalsTex, float4(texCoord, 0, 0)).xyz);
        //const float3 centerNormal = tex2Dlod(normalsTex, float4(texCoord, 0, 0)).xyz;

        float4 aoSample;
        float3 sampleNorm;
        float3 samplePos;
        float w;
        float4 sampleTexCoord;
        float depthFactor;
        float normalFactor;
        float convergenceFactor;
        float sampleDepth;

        for (int i = 0; i < NUM_SSAO_FILTERSAMPLES; ++ i)
        {
                sampleTexCoord = float4(texCoord + filterOffs[i] * scale, 0, 0);

                aoSample = tex2Dlod(ssaoTex, sampleTexCoord);
                sampleNorm = normalize(tex2Dlod(normalsTex, sampleTexCoord).xyz);
                //sampleNorm = tex2Dlod(normalsTex, sampleTexCoord).xyz;

                // check depth discontinuity
                sampleDepth = tex2Dlod(colorsTex, sampleTexCoord).w;
                //sampleDepth = aoSample.w;
                
                //depthFactor = max(step(1e-1f, 1.0f - abs(1.0f - eyeSpaceDepth / sampleDepth)), 1e-3f);
                depthFactor = 1.0f / max(abs(eyeSpaceDepth - sampleDepth), 1e-3f);
                //normalFactor = max(step(0.6f, dot(sampleNorm, centerNormal)), 1e-6f);
                normalFactor = max(dot(sampleNorm, centerNormal), 1e-6f);
                convergenceFactor = min(200.0f, aoSample.y) * 0.01f;

                // combine the weights
                w = depthFactor * normalFactor * convergenceFactor;

                average += aoSample.x * w;
                total_w += w;
        }

        average /= max(total_w, 1e-1f);

        return saturate(average );
}

/** Function combining image and indirect illumination buffer using a 
        depth and normal aware discontinuity filter.
*/
pixel combine(fragment IN, 
                          uniform sampler2D colorsTex,
                          uniform sampler2D ssaoTex,
                          uniform sampler2D normalsTex,
                          uniform sampler2D offsetTex,
                          uniform float2 filterOffs[NUM_SSAO_FILTERSAMPLES],
                          uniform float filterWeights[NUM_SSAO_FILTERSAMPLES],
                          )
{
        pixel OUT;

        float4 col = tex2Dlod(colorsTex, float4(IN.texCoord, 0, 0));
        float4 ao = tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));

        if ((ao.y < 70.0f) && (col.w < 1e10f))
        //if (col.w < 1e10f)
        {
                const float scaleFactor = 1.0f;
                const float adaptFactor = 10.0f;
                
                const float scale =     adaptFactor * scaleFactor * ao.z  / (adaptFactor + ao.y);
                        
                ao.x = DiscontinuityFilter(IN.texCoord, ao, col, ssaoTex, normalsTex, colorsTex, filterOffs, filterWeights, scale);
        }

        OUT.illum_col.xyz = col.xyz * ao.x;

        //OUT.illum_col.xyz = float3(0, clamp(1.0f - ao.y * 1e-2f, 0, 1), 1);
        OUT.illum_col.w = col.w;

        return OUT;
}