Changeset 3296 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src

Timestamp:

02/10/09 17:43:43 (16 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling/src

Files:

• DeferredRenderer.cpp (modified) (4 diffs)
• DeferredRenderer.h (modified) (1 diff)
• shaders/combineSsao.cg (modified) (3 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp

@@ -395 +395 @@
         sCgGiProgram = sm->CreateFragmentProgram("globillum", "main", "GiFrag");
         sCgCombineIllumProgram = sm->CreateFragmentProgram("globillum", "combine", "CombineGi");
-        sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "CombineSsaoHalfRes", "CombineSsao");
+        //sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "CombineSsaoHalfRes", "CombineSsao");
+        sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "CombineSsaoFullRes", "CombineSsao");
         sCgAntiAliasingProgram = sm->CreateFragmentProgram("antialiasing", "main", "AntiAliasing");
         sCgToneProgram = sm->CreateFragmentProgram("tonemap", "ToneMap", "ToneMap");
@@ -624 +625 @@
 }
 
+#if 0
 
 void DeferredRenderer::PrepareSsaoFilter()
@@ -647 +649 @@
         }
 }
+
+#else
+
+void DeferredRenderer::PrepareSsaoFilter()
+{
+        const float filterWidth = 1.0f;
+
+        PoissonDiscSampleGenerator2D poisson(NUM_SSAO_FILTER_SAMPLES, 1.0f);
+        poisson.Generate((float *)ssaoFilterOffsets);
+
+        const float xoffs = (float)filterWidth / mWidth;
+        const float yoffs = (float)filterWidth / mHeight;
+
+        for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES / 2; ++ i)
+        {
+                float x = xoffs * (i - NUM_SSAO_FILTER_SAMPLES / 4);
+                float y = 0;
+
+                ssaoFilterWeights[i] = GaussianDistribution(x, y, 1.0f);
+                
+                ssaoFilterOffsets[2 * i + 0] = xoffs;
+                ssaoFilterOffsets[2 * i + 1] = yoffs;
+        }
+
+        for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES / 2; ++ i)
+        {
+                float x = 0;
+                float y = yoffs * (i - NUM_SSAO_FILTER_SAMPLES / 4);
+
+                ssaoFilterWeights[i] = GaussianDistribution(x, y, 1.0f);
+                //ssaoFilterWeights[i] = 1.0f;
+
+                ssaoFilterOffsets[2 * (NUM_SSAO_FILTER_SAMPLES / 2 + i) + 0] *= xoffs;
+                ssaoFilterOffsets[2 * (NUM_SSAO_FILTER_SAMPLES / 2 + i) + 1] *= yoffs;
+        }
+}
+
+#endif
 
 
@@ -983 +1023 @@
 
         for (int j = 0; j < 4; ++ j, ++ i)
+        {
                 sCgCombineSsaoProgram->SetValue3f(i, mCornersView[j].x, mCornersView[j].y, mCornersView[j].z);
+        }
+
+        sCgCombineSsaoProgram->SetValue1f(i ++, mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetWidth());
+        sCgCombineSsaoProgram->SetValue1f(i ++, mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetHeight());
+
+        DrawQuad(sCgCombineSsaoProgram);
+        
+        PrintGLerror("combine ssao");
+}
+
+
+void DeferredRenderer::CombineSsao2(FrameBufferObject *fbo)
+{
+        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
+        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();
+        GLuint ssaoTex = mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetTexture();
+        
+        FlipFbos(fbo);
+
+        int i = 0;
+
+        sCgCombineSsaoProgram->SetTexture(i ++, colorsTex);
+        sCgCombineSsaoProgram->SetTexture(i ++, normalsTex);
+        sCgCombineSsaoProgram->SetTexture(i ++, ssaoTex);
+
+        sCgCombineSsaoProgram->SetArray2f(i ++, (float *)ssaoFilterOffsets, NUM_SSAO_FILTER_SAMPLES);
+        sCgCombineSsaoProgram->SetArray1f(i ++, (float *)ssaoFilterWeights, NUM_SSAO_FILTER_SAMPLES);
+        sCgCombineSsaoProgram->SetValue1f(i ++, mSsaoFilterRadius);
+
+        sCgCombineSsaoProgram->SetMatrix(i++, mProjViewMatrix);
+
+        for (int j = 0; j < 4; ++ j, ++ i)
+        {
+                sCgCombineSsaoProgram->SetValue3f(i, mCornersView[j].x, mCornersView[j].y, mCornersView[j].z);
+        }
 
         sCgCombineSsaoProgram->SetValue1f(i ++, mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetWidth());

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h

@@ -168 +168 @@
         void DepthOfField(FrameBufferObject *fbo);
 
+        void CombineSsao2(FrameBufferObject *fbo);
 
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsao.cg

@@ -115 +115 @@
         float4 ao =  tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));
 
-#if 0 // for half resolution
-
         // the following has to be done for half resolution ssao:
         // get the minimum convergence by exactly sampling the 4 surrounding
@@ -141 +139 @@
         const float convergence = minConvergence;
 
-#else
-        
-        // just take unfiltered convergence in current pixel
-        const float convergence = ao.y;
-
-#endif
         
         // filter reaches size 1 pixel when sample size reaches threshold 
@@ -188 +180 @@
         return OUT;
 }
+
+
+/** Function combining image and indirect illumination buffer using a 
+        depth and normal aware discontinuity filter. We assume that 
+        we are using half resolution ssao for this version of the combineSsao
+*/
+pixel CombineSsaoFullRes(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 float ssaoFilterRadius,
+                                                 uniform float4x4 modelViewProj,
+                                                 uniform float3 bl,
+                                                 uniform float3 br,
+                                                 uniform float3 tl,
+                                                 uniform float3 tr,
+                                                 uniform float w,
+                                                 uniform float h
+                                                 )
+{
+        pixel OUT;
+
+        float4 col = tex2Dlod(colorsTex, float4(IN.texCoord, 0, 0));
+        float4 ao =  tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));
+
+        // just take unfiltered convergence in current pixel
+        const float convergence = ao.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) && (col.w < 1e10f))
+        {
+                const float distanceScale = 1.0f;
+
+                // descend to zero filter size after reaching thres pixels
+                const float convergenceWeight = SSAO_CONVERGENCE_THRESHOLD / (ssaoFilterRadius - 1.0f);
+                const float convergenceScale = convergenceWeight / (convergence + convergenceWeight);
+                const float scale = ssaoFilterRadius * convergenceScale * distanceScale;
+
+                // the filtered ssao value
+                ao.x = DiscontinuityFilter(IN.texCoord, ao, col, ssaoTex, normalsTex, colorsTex, filterOffs, scale, bl, br, tl, tr);
+        }
+
+        // just apply ssao if we are not in the sky
+        if (col.w < 1e10f)
+                OUT.illum_col.xyz = col.xyz * max(2e-2f, 1.0f - ao.x);
+                //OUT.illum_col.xyz = col.xyz * ao.x;
+        else
+                OUT.illum_col.xyz = col.xyz;
+
+        OUT.illum_col.w = col.w;
+
+        return OUT;
+}