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

#include "../shaderenv.h"
#include "common.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_FILTER_SAMPLES],
                                                  uniform float filterWeights[NUM_SSAO_FILTER_SAMPLES],
                                                  float scale
                                                  )
{
        float average = .0f;
        float total_w = .0f;

        const float eyeSpaceDepth = color.w;

        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_FILTER_SAMPLES; ++ i)
        {
                sampleTexCoord = float4(texCoord + filterOffs[i] * scale, 0, 0);

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

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

                // combine the weights
                w = filterWeights[i] * convergenceFactor * depthFactor * normalFactor;
                //w = normalFactor * convergenceFactor;

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

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

        return saturate(average);
}



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

        //const float3 centerPos = ReconstructSamplePos(ssaoTex, texCoord, bl, br, tl, tr);
        const float3 centerPos = ReconstructSamplePos(colorsTex, texCoord, bl, br, tl, tr);
        const float3 centerNormal = tex2Dlod(normalsTex, float4(texCoord, 0, 0)).xyz;

        float4 aoSample;
        float3 sampleNorm;
        float3 samplePos;
        float w;
        float4 sampleTexCoord;
        float spatialFactor;
        float normalFactor;
        float convergenceFactor;
        float len;

        const float convergenceThresh = 200.0f;

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

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

                // check spatial discontinuity

                // note: using the depth from the color texture is not 100% correct as depth was
                // not scaled with the interpolated view vector depth yet ...
                samplePos = ReconstructSamplePos(colorsTex, sampleTexCoord.xy, bl, br, tl, tr);
                //samplePos = ReconstructSamplePos(ssaoTex, sampleTexCoord.xy, bl, br, tl, tr);

                len = min(SqrLen(centerPos - samplePos), 1e2f);
                spatialFactor = 1.0f / max(len, 1e-3f);

                //normalFactor = max(step(.0f, dot(sampleNorm, centerNormal)), 1e-2f);
                convergenceFactor = aoSample.y + 1.0f;
                
                // combine the weights
                w = convergenceFactor * convergenceFactor * spatialFactor;// * normalFactor;
                
                average += aoSample.x * w;
                total_w += w;
        }

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

        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 float2 filterOffs[NUM_SSAO_FILTER_SAMPLES],
                          uniform float filterWeights[NUM_SSAO_FILTER_SAMPLES],
                          uniform float4x4 modelViewProj,
                          uniform float3 bl,
                          uniform float3 br,
                          uniform float3 tl,
                          uniform float3 tr
                          )
{
        pixel OUT;

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

        // get the minimum convergence by exactly sampling the 4 surrounding
        // texels in the old texture, otherwise flickering because convergence
        // will be interpolated when upsampling and filter size does not match!
        float4 texelCenterConv;
        const float w = 512.0f; const float h = 384.0f;
        const float xoffs = .5f / w; const float yoffs = .5f / h;

        // get position exactly between old texel centers
        float2 center;
        center.x = float(floor(IN.texCoord.x * w - .5f) + 1.0f) / w;
        center.y = float(floor(IN.texCoord.y * h - .5f) + 1.0f) / h;

        texelCenterConv.x = tex2Dlod(ssaoTex, float4(center + float2(xoffs, yoffs), 0, 0)).y;
        texelCenterConv.y = tex2Dlod(ssaoTex, float4(center + float2(xoffs, -yoffs), 0, 0)).y;
        texelCenterConv.z = tex2Dlod(ssaoTex, float4(center + float2(-xoffs, yoffs), 0, 0)).y;
        texelCenterConv.w = tex2Dlod(ssaoTex, float4(center + float2(-xoffs, -yoffs), 0, 0)).y;

        const float m1 = min(texelCenterConv.x, texelCenterConv.y);
        const float m2 = min(texelCenterConv.z, texelCenterConv.w);

        const float minConvergence = min(m1, m2);

        const float convergence = step(200.0f, minConvergence) * minConvergence;
        //const float convergence = ao.y;

        // filter reaches size 1 after thres samples
        const float thres = 500.0f; 

        // filter up to a certain convergance value and leave out background (sky) by checking depth
        if ((convergence < thres) && (col.w < 1e10f))
        {
                const float distanceScale = 1.0f;

                // descend to zero filter size after reaching thres pixels
                const float convergenceWeight = thres / (SSAO_FILTER_WIDTH - 1.0f);
                const float convergenceScale = convergenceWeight / (convergence + convergenceWeight);
                const float scale = SSAO_FILTER_WIDTH * convergenceScale * distanceScale;

                // the filtered ssao value
                ao.x = DiscontinuityFilter2(IN.texCoord, ao, col, ssaoTex, normalsTex, colorsTex, filterOffs, scale, bl, br, tl, tr);
        }

        if (col.w < 1e10f)
                OUT.illum_col.xyz = col.xyz * ao.x;
        else
                OUT.illum_col.xyz = col.xyz;

        //OUT.illum_col.xyz = float3(ao.x, ao.x, step(thres, convergence));
        //OUT.illum_col.xyz = float3(ao.x, ao.x, ao.x);
        //OUT.illum_col.xyz = float3(0, clamp(1.0f - ao.y * 1e-3f, 0, 1), 1);
        //OUT.illum_col.xyz = float3(0, 1.0f - step(0.5f + NUM_SAMPLES, convergence), 1);
        OUT.illum_col.w = col.w;

        return OUT;
}



/** Function combining image and indirect illumination buffer using a 
        depth and normal aware discontinuity filter.
*/
pixel SmoothSsao(fragment IN, 
                                 uniform sampler2D ssaoTex)
{
        pixel OUT;

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

        float4 dummy;
        const float xoffs = .5f / 1024.0f; const float yoffs = .5f / 768.0f;

        // get positions exactly between old texel centers
        dummy.x = tex2Dlod(ssaoTex, float4(IN.texCoord + float2(xoffs, 0), 0, 0)).y;
        dummy.y = tex2Dlod(ssaoTex, float4(IN.texCoord + float2(0, -yoffs), 0, 0)).y;
        dummy.z = tex2Dlod(ssaoTex, float4(IN.texCoord + float2(-xoffs, 0), 0, 0)).y;
        dummy.w = tex2Dlod(ssaoTex, float4(IN.texCoord + float2(0, yoffs), 0, 0)).y;

        const float m1 = min(dummy.x, dummy.y);
        const float m2 = min(dummy.z, dummy.w);

        ao.y = min(ao.y, min(m1, m2));

        return OUT;
}