source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsaoSep.cg @ 3361

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


float ComputeConvergenceHalfRes(uniform sampler2D ssaoTex,
                                                                float2 texCoord, 
                                                                float2 halfres)
{
    // the following has to be done for half resolution ssao:
        // 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 xoffs = .5f / halfres.x; const float yoffs = .5f / halfres.y;

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

        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);
        return minConvergence;
}


float2 FilterSample(float4 sampleTexCoord, 
                                        uniform sampler2D ssaoTex,
                                        uniform sampler2D colorsTex,
                                        float3 centerPos,
                                        float3 bl,
                                        float3 br,
                                        float3 tl,
                                        float3 tr,
                                        float maxConvergence,
                                        float spatialWeight)
{
        float2 aoSample = tex2Dlod(ssaoTex, sampleTexCoord);
                
        // 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 ...
        float3 samplePos = ReconstructSamplePos(colorsTex, sampleTexCoord.xy, bl, br, tl, tr);
        //samplePos = ReconstructSamplePos(ssaoTex, sampleTexCoord.xy, bl, br, tl, tr);

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

        float convergenceFactor = min(aoSample.y + 1.0f, maxConvergence);
        //convergenceFactor *= convergenceFactor;

        // combine the weights
        //float w = convergenceFactor * exp(1.0f + spatialFactor);
        float w = convergenceFactor * spatialFactor;
        //float w = spatialFactor;
        float average = aoSample.x * w;

        return float2(average, w);
}


/** Filter taking into account depth, normal discontinuities 
   and ssao convergence of a sample (the higher the more reliably
   has the sample a correct ssao value)
*/
float FilterXY(float2 texCoord,
                           uniform sampler2D ssaoTex,
                           uniform sampler2D colorsTex,
                           float3 bl,
                           float3 br,
                           float3 tl,
                           float3 tr,
                           float2 xyStep,
                           float convergence,
                           float maxConvergence,
                           float spatialWeight
                           )
{
        float2 result = float2(0.0f, 0.0f);
        
        const float3 centerPos = ReconstructSamplePos(colorsTex, texCoord, bl, br, tl, tr);

        const float scale = saturate((SSAO_CONVERGENCE_THRESHOLD - convergence) / SSAO_CONVERGENCE_THRESHOLD);
        //const int radius = SSAO_FILTER_RADIUS * saturate((SSAO_CONVERGENCE_THRESHOLD - convergence) / SSAO_CONVERGENCE_THRESHOLD);
        
        //for (int i = -radius; i <= radius; ++ i)
        for (int i = -SSAO_FILTER_RADIUS; i <= SSAO_FILTER_RADIUS; ++ i)
        {
                const float4 sampleTexCoord = float4(texCoord + i * xyStep * scale, .0f, .0f);
                result += FilterSample(sampleTexCoord, ssaoTex, colorsTex, centerPos, bl, br, tl, tr, maxConvergence, spatialWeight);
        }

        result.x /= max(result.y, 1e-6f);
        return saturate(result.x);
}


/** In between step that only filters in one direction
*/
pixel FilterSsaoHalfRes(fragment IN, 
                                                uniform sampler2D colorsTex,
                                                uniform sampler2D ssaoTex,
                                                uniform float3 bl,
                                                uniform float3 br,
                                                uniform float3 tl,
                                                uniform float3 tr,
                                                uniform float2 res
                                                 )
{
        pixel OUT;

        const float depth = tex2Dlod(colorsTex, float4(IN.texCoord, 0, 0)).w;

        OUT.illum_col = tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));
        // compute minimal convergence for savetly reasons, write it out
        const float convergence = ComputeConvergenceHalfRes(ssaoTex, IN.texCoord, res * 0.5f);
        OUT.illum_col.y = convergence;

        const float2 xyStep = float2(1.0f / res.x, 0);

        // filter reaches size 1 pixel when sample size reaches threshold 
        // afterwards we do not use the filter anymore

        // filter up to a certain convergance value and leave out background (sky) by checking depth
        if ((convergence < SSAO_CONVERGENCE_THRESHOLD) && (depth < DEPTH_THRESHOLD))
        {
                // the filtered ssao value
                OUT.illum_col.x = FilterXY(IN.texCoord, ssaoTex, colorsTex, bl, br, tl, tr, xyStep, convergence, maxConvergence, spatialWeight);
        }

        return OUT;
}

/** In between step that only filters in one direction
*/
pixel FilterSsaoFullRes(fragment IN, 
                                                uniform sampler2D colorsTex,
                                                uniform sampler2D ssaoTex,
                                                uniform float3 bl,
                                                uniform float3 br,
                                                uniform float3 tl,
                                                uniform float3 tr,
                                                uniform float2 res,
                                                uniform float maxConvergence,
                                                uniform float spatialWeight
                                                )
{
        pixel OUT;

        const float depth = tex2Dlod(colorsTex, float4(IN.texCoord, 0, 0)).w;

        OUT.illum_col = tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));
        // just take unfiltered convergence in current pixel
        const float convergence = OUT.illum_col.y;

        // filter reaches size 1 pixel when sample size reaches threshold 
        // afterwards we do not use the filter anymore

        float2 xyStep = float2(1.0f / res.x, 0);

        // filter up to a certain convergance value and leave out background (sky) by checking depth
        if ((convergence < SSAO_CONVERGENCE_THRESHOLD) && (depth < DEPTH_THRESHOLD))
        {
                // the filtered ssao value
                OUT.illum_col.x = FilterXY(IN.texCoord, ssaoTex, colorsTex, bl, br, tl, tr, xyStep, convergence, maxConvergence, spatialWeight);
        }

        return OUT;
}


/** Function combining image and indirect illumination buffer using a 
    depth and convergence aware discontinuity filter.
*/
pixel CombineSsao(fragment IN, 
                                  uniform sampler2D colorsTex,
                                  uniform sampler2D ssaoTex,
                                  uniform float3 bl,
                                  uniform float3 br,
                                  uniform float3 tl,
                                  uniform float3 tr,
                                  uniform float2 res,
                                  uniform float maxConvergence,
                                  uniform float spatialWeight
                                  )
{
        pixel OUT;

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

        const float depth = col.w;
        // just take unfiltered convergence in current pixel
        const float convergence = ao.y;

        const float2 xyStep = float2(.0f, 1.0f / res.y);
        
        // filter reaches size 1 pixel when sample size reaches threshold 
        // afterwards we do not use the filter anymore

        // filter up to a certain convergance value and leave out background (sky) by checking depth
        if ((convergence < SSAO_CONVERGENCE_THRESHOLD) && (depth < DEPTH_THRESHOLD))
        {
                // the filtered ssao value
                ao.x = FilterXY(IN.texCoord, ssaoTex, colorsTex, bl, br, tl, tr, xyStep, convergence, maxConvergence, spatialWeight);
        }

        const float minAO = 1e-3f;

        // just apply ssao if we are not in the sky
        if (depth < DEPTH_THRESHOLD)
        {
                //OUT.illum_col.xyz = col.xyz * max(minAO, 1.0f - ao.x);
                OUT.illum_col.xyz = max(minAO, 1.0f - ao.x);
                //OUT.illum_col.xyz = max(minAO, 1.0f - ao.x);
        }
        else
        {
                OUT.illum_col.xyz = col.xyz;
        }

        //OUT.illum_col.xyz = float3(ao.x * 1e1f, col.yz);

        //OUT.illum_col.xyz = float3(ao.w * 5e-1f, 0, 0);
        //OUT.illum_col.xyz = float3(ao.z * 1e-3f);
        //OUT.illum_col.xyz = float3(ao.y * 1e-3f);
        //OUT.illum_col.xyz = ao.xyz;

        OUT.illum_col.w = col.w;

        return OUT;
}