Changeset 3310 for GTP/trunk

Timestamp:

02/13/09 15:59:33 (16 years ago)

Author:

mattausch

Message:

debug version

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling

Files:

• sibenik.env (modified) (1 diff)
• src/DeferredRenderer.cpp (modified) (2 diffs)
• src/shaders/combineSsaoSep.cg (modified) (3 diffs)
• src/shaders/ssao.cg (modified) (9 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/sibenik.env

@@ -106 +106 @@
 ssaoSampleIntensity=0.8f
 # ssao temporal coherence factor
-tempCohFactor=150.0f
+tempCohFactor=100.0f
 # ssao filter radius
 ssaoFilterRadius=12.0f

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

@@ -208 +208 @@
         case DeferredRenderer::SAMPLING_QUADRATIC:
                 {
-                        static QuadraticDiscSampleGenerator2D g(NUM_PRECOMPUTED_SAMPLES, 1.0f);
+                        QuadraticDiscSampleGenerator2D g(NUM_PRECOMPUTED_SAMPLES, 1.0f);
                         //static QuadraticDiscSampleGenerator2D g(NUM_SAMPLES, 1.0f);
                         g.Generate((float *)samples2);
@@ -741 +741 @@
         sCgSsaoProgram->SetTexture(i ++, noiseTex2D);
 
-        sCgSsaoProgram->SetValue1f(i ++, (mUseTemporalCoherence && !mRegenerateSamples) ? tempCohFactor : 0);
+        sCgSsaoProgram->SetValue1f(i ++, (mUseTemporalCoherence && !mRegenerateSamples) ? tempCohFactor : .0f);
         
         if (/*mUseTemporalCoherence || */mRegenerateSamples)

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

@@ -114 +114 @@
 }
 
+
+/** 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);
+        }
+
+        return OUT;
+}
+
+
 /** In between step that only filters in one direction
 */
@@ -137 +175 @@
         // afterwards we do not use the filter anymore
 
-        float2 xyStep = float2(1.0f / res.x, 0);
+        const float2 xyStep = float2(1.0f / res.x, 0);
 
         // filter up to a certain convergance value and leave out background (sky) by checking depth
@@ -149 +187 @@
 }
 
-/** 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);
-        }
-
-        return OUT;
-}
 
 /** Function combining image and indirect illumination buffer using a 

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

@@ -48 +48 @@
         weight of the pixel in the new frame.
 */
-inline float2 temporalSmoothing(float4 worldPos,
+inline float3 temporalSmoothing(float4 worldPos,
                                                                 float eyeSpaceDepth,
                                                                 float2 texcoord0,
@@ -96 +96 @@
         // the weight of the accumulated samples from the previous frames
         float w;
+        float idx;
 
         //////////////
@@ -108 +109 @@
                 // pixel valid => retrieve the convergence weight
                 w = oldPixel.y;
+                idx = oldPixel.z;
         }
         else
         {       
-                w = 0.0f;
-        }
-
-        return float2(ssao, w);
+                w = .0f;
+                idx = .0f;
+        }
+
+        return float3(ssao, w, idx);
 }
 
@@ -141 +144 @@
         float numSamples = .0f;
         float validSamples = .0f;
+
 
         for (int i = 0; i < NUM_PRECOMPUTED_SAMPLES; ++ i) 
@@ -247 +251 @@
                 //-- (affects performance for some reason!)
 
-                if (convergence < SSAO_CONVERGENCE_THRESHOLD)
+                if (1)//convergence < SSAO_CONVERGENCE_THRESHOLD)
                 {
                         float2 mynoise = tex2Dlod(noiseTex, float4(IN.texCoord * 4.0f, 0, 0)).xy;
                         //offset = myreflect(samples[i], mynoise);
-                        offset = myrotate(samples[i + idx], mynoise.x);
+                        offset = myrotate(samples[i], mynoise.x);
+                        //offset = myrotate(samples[i + idx], mynoise.x);
                 }
                 else
                 {
-                        offset = samples[i + idx];
+                        //offset = samples[i + idx];
+                        offset = samples[i];
                 }
                 
@@ -382 +388 @@
         //-- compute temporal reprojection
 
-        float2 temporalVals = temporalSmoothing(eyeSpacePos, eyeSpaceDepth, IN.texCoord, oldEyePos,
+        float3 temporalVals = temporalSmoothing(eyeSpacePos, eyeSpaceDepth, IN.texCoord, oldEyePos,
                                                 oldTex, oldModelViewProj, 
                                                                                         colors, 
@@ -394 +400 @@
         float oldWeight = temporalVals.y;
 
-        float usedWeight = min(temporalCoherence, abs(oldWeight));
-        int idx = (int)oldWeight % (int)temporalCoherence;
+        int idx = (int)temporalVals.z;
+                //min(0, (int)oldWeight % max((int)temporalCoherence, 1));
 
         float3 ao;
@@ -402 +408 @@
         if (eyeSpaceDepth < DEPTH_THRESHOLD)
         {
-                ao = ssao(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, scaleFactor, bl, br, tl, tr, normalize(viewDir), usedWeight, sampleIntensity, isMovingObject, idx);
+                ao = ssao(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, 
+                              scaleFactor, bl, br, tl, tr, normalize(viewDir), oldWeight, 
+                                  sampleIntensity, isMovingObject, idx);
                 //ao = ssao2(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, scaleFactor, bl, br, tl, tr, normalize(viewDir), normals, sampleIntensity);
         }
@@ -428 +436 @@
                 if (ao.y > completelyResetThres) 
                 {
-                        oldWeight = .0f; 
+                        oldWeight = .0f;
+                        idx = .0f;
                 }
                 else if (ao.y > partlyResetThres)
                 {
                         oldWeight = min(oldWeight, 4.0f * newWeight);
-                        //oldWeight = .0f; 
+                        idx = oldWeight;
                 }
         }
+
+        float usedWeight = min(temporalCoherence, oldWeight);
+
 
         //////////
         //-- blend ao between old and new samples (and avoid division by zero)
 
-        OUT.illum_col.x = ao.x * newWeight + oldSsao * usedWeight;
-        OUT.illum_col.x /= (newWeight + usedWeight);
+        OUT.illum_col.x = ao.x * newWeight;// + oldSsao * usedWeight;
+        OUT.illum_col.x /= max(newWeight + usedWeight, 1);
+
+        //if (oldWeight >= 10000) oldWeight = 1000;
 
         // the new weight for the next frame
         //const float combinedWeight = clamp(newWeight + oldWeight, .0f, temporalCoherence);
-        const float combinedWeight = newWeight + oldWeight;
+        float combinedWeight = newWeight + oldWeight;
+
+        clamp(combinedWeight, 0, 1000);
 
         OUT.illum_col.y = combinedWeight;