Changeset 3361 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders

Timestamp:

04/20/09 09:11:32 (16 years ago)

Author:

mattausch

Message:

 

Location:

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

Files:

• combineSsaoSep.cg (modified) (1 diff)
• deferred.cg (modified) (4 diffs)
• ssao.cg (modified) (10 diffs)

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

@@ -248 +248 @@
         }
 
+        //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);x
+        //OUT.illum_col.xyz = float3(ao.y * 1e-3f);
         //OUT.illum_col.xyz = ao.xyz;
 

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

@@ -40 +40 @@
 
         // hack: prevent to shade the sky
-#if 1
+#if 0
         if (color.w > DEPTH_THRESHOLD)
         {
@@ -250 +250 @@
 
         // compute position from old frame for dynamic objects + translational portion
-        //const float3 translatedPos = difVec - oldEyePos + worldPos.xyz;
+        const float3 translatedPos = difVec - oldEyePos + worldPos.xyz;
         // don't use difVec here: want to detect if the actual pixel has changed => ssao changed
-        const float3 translatedPos = -oldEyePos + worldPos.xyz;
+        //const float3 translatedPos = -oldEyePos + worldPos.xyz;
 
 
@@ -293 +293 @@
         // means that we only use slight temporal coherence over some frames
         // so that there is no noticeable drag
-        const float pixelCouldBeValid = 2.0f;
+        const float pixelCouldBeValid = 4.0f;
         // this pixel information has to be discarded in order to not create artifacts
         const float pixelIsNotValid = 100.0f;
@@ -306 +306 @@
         }
         else if ( // check if changed from dynamic to not dynamic object
-                 ((oldDynamic && !newDynamic) || (!oldDynamic && newDynamic) ||
+                 (
+                          (oldDynamic && !newDynamic) || (!oldDynamic && newDynamic) ||
                          (
                           (oldEyeSpaceDepth < DEPTH_THRESHOLD) && (projectedEyeSpaceDepth < DEPTH_THRESHOLD) &&
                           (oldDynamic || newDynamic) &&  // check if we have a dynamic object 
-                          (depthDif > MIN_DEPTH_DIFF)))) // and there is a depth discontinuity
+                          (depthDif > MIN_DEPTH_DIFF)))
+                          ) // and there is a depth discontinuity
         {       
                 isPixelValid = pixelCouldBeValid;

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

@@ -308 +308 @@
 }
 
+//#define TRYOUT
+
+#ifdef TRYOUT
 
 /** The ssao shader returning the an intensity value between 0 and 1.
@@ -399 +402 @@
                 // check if the samples have been valid in the last frame
                 // only mark sample as invalid if in the last / current frame
-                // they possibly have any influence on the ao
+                // they possibly have any influence on the AO
 
                 const float changeFactor = sampleColor.y;
@@ -412 +415 @@
                 const float partlyResetThres = 1.0f;
 
-                const float tooFarAway = step(0.5f, lengthToSample - changeFactor);
+                const float tooFarAway = step(.5f, lengthToSample - changeFactor);
                 if (0)//pixelValid <= partlyResetThres)
                         validSamples = max(validSamples, pixelValid * (1.0f - tooFarAway) * step(-0.1f, cosAngle));
@@ -451 +454 @@
 }
 
+#else
+
+float3 ssao(fragment IN,
+                        sampler2D colors,
+                        sampler2D noiseTex,
+                        sampler2D samples,
+                        float3 normal,
+                        float3 centerPosition,
+                        float radius,
+                        float3 bl,
+                        float3 br,
+                        float3 tl,
+                        float3 tr, 
+                        float3 viewDir,
+                        float convergence,
+                        float sampleIntensity,
+                        bool isMovingObject,
+                        float oldIdx,
+                        sampler2D attribsTex
+                        )
+{
+        float total_ao = .0f;
+        float validSamples = .0f;
+        float numSamples = .0f;
+
+        float3 diffVec = tex2Dlod(attribsTex, float4(IN.texCoord, 0, 0)).xyz;
+
+        for (int i = 0; i < NUM_SAMPLES; ++ i) 
+        {
+                float2 offset;
+
+                const float2 ssaoOffset = 
+                        tex2Dlod(samples, float4((0.5f + i + oldIdx) / NUM_PRECOMPUTED_SAMPLES, .5f, .0f, .0f)).xy;
+
+
+                ////////////////////
+                //-- add random noise: reflect around random normal vector 
+                //-- (affects performance for some reason!)
+
+                if (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], mynoise.x);
+                        offset = myrotate(ssaoOffset, mynoise.x);
+                }
+                else
+                {
+                        offset = ssaoOffset;
+                }
+
+
+                // weight with projected coordinate to reach similar kernel size for near and far
+                const float2 texcoord = IN.texCoord.xy + offset * radius;
+
+                const float4 sampleColor = tex2Dlod(colors, float4(texcoord, .0f, .0f));
+                const float3 samplePos = ReconstructSamplePos(sampleColor.w, texcoord, bl, br, tl, tr);
+                
+                
+
+                ////////////////
+                //-- compute contribution of sample using the direction and angle
+
+                float3 dirSample = samplePos - centerPosition;
+
+                const float minDist = 1e-6f;
+                const float eps = 1e-3f;
+
+                const float lengthToSample = length(dirSample);
+                const float sampleWeight = 1.0f / max(lengthToSample, eps);
+
+                dirSample /= max(length(dirSample), minDist); // normalize
+
+                // angle between current normal and direction to sample controls AO intensity.
+                const float cosAngle = dot(dirSample, normal);
+
+                //const float aoContrib = sampleIntensity / sqrLen;
+                const float aoContrib = sampleIntensity * sampleWeight;
+                //const float aoContrib = (1.0f > lengthToSample) ? occlusionPower(9e-2f, DISTANCE_SCALE + lengthToSample): .0f;
+
+                total_ao += max(cosAngle, .0f) * aoContrib;
+
+                ++ numSamples;
+
+
+#ifdef PERFORMANCE_TEST
+                // check if the samples have been valid in the last frame
+                // only mark sample as invalid if in the last / current frame
+                // they possibly have any influence on the ao
+
+                //const float pixelValid = sampleColor.x;
+                //const float pixelValid = length(sampleDiffVec - diffVec) < 1e-3f ? .0f : 10.0f;
+                //float pixelValid = max(sampleColor.x, length(sampleDiffVec - diffVec) < 1e-3f ? .0f : 10.0f);
+                float pixelValid = sampleColor.x;
+
+                if (pixelValid < 1)
+                {
+                        const float3 sampleDiffVec = tex2Dlod(attribsTex, float4(texcoord, .0f, .0f)).xyz;
+                        pixelValid = length(sampleDiffVec - diffVec) < 1e-3f ? .0f : 10.0f;
+                }
+
+                // hack:
+                // we check if the sample could have been near enough to the current pixel 
+                // or if the angle is small enough
+                // to have any influence in the current or last frame
+
+#if 1
+                const float changeFactor = sampleColor.y;
+                const float partlyResetThres = 1.0f;
+
+                if (0)//pixelValid <= partlyResetThres)
+                {
+                        const float tooFarAway = step(0.5f, lengthToSample - changeFactor);
+                        validSamples = max(validSamples, pixelValid * (1.0f - tooFarAway) * step(-0.1f, cosAngle));
+                }
+                else
+                {
+                        validSamples = max(validSamples, pixelValid);
+                }
+#endif
+
+#ifdef USE_GTX
+                // we can bail out early and use a minimal #samples)
+                // if some conditions are met as long as the hardware supports it
+                if (numSamples >= MIN_SAMPLES)
+                {
+                        //break;
+                        // if the pixel belongs to a static object and all the samples stay valid in the current frame
+                        if (!isMovingObject && (validSamples < 1.0f) && (convergence > NUM_SAMPLES)) break;
+                        // if the pixel belongs to a dynamic object but the #accumulated samples for this pixel is sufficiently high 
+                        // (=> there was no discontinuity recently)
+                        //else if (isMovingObject && (convergence > SSAO_CONVERGENCE_THRESHOLD)) break;
+                        else if (isMovingObject && (convergence > NUM_SAMPLES * 5)) break;
+                }
+#endif
+
+#endif // PERFORMANCE_TEST
+        }
+
+        // "normalize" ao contribution
+        total_ao /= numSamples;
+
+#if 1
+        // if surface normal perpenticular to view dir, approx. half of the samples will not count
+        // => compensate for this (on the other hand, projected sampling area could be larger!)
+        const float viewCorrection = 1.0f + VIEW_CORRECTION_SCALE * max(dot(viewDir, normal), 0.0f);
+        total_ao *= viewCorrection;
+#endif
+
+        //return float3(total_ao, validSamples, numSamples);
+        return float3(min(1.0f, total_ao), validSamples, numSamples);
+}
+#endif
 
 
@@ -501 +657 @@
         
 #ifdef PERFORMANCE_TEST 
-//#if 0
         float3 diffVec = tex2Dlod(attribsTex, float4(IN.texCoord, 0, 0)).xyz;
 
@@ -530 +685 @@
         const float3 diffVec = float3(.0f);
         const bool isMovingObject = false;
-        const float oldSsao = 0;
-        
-        float oldWeight = 0;
-        float oldIdx    = 0;
+        const float oldSsao = .0f;
+        
+        float oldWeight = .0f;
+        float oldIdx    = .0f;
         
 #endif
@@ -544 +699 @@
                 if (1)
                 {
+#ifdef TRYOUT
                         ao = ssao(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, 
                                       radiusMult, bl, br, tl, tr, normalize(viewDir),
                                           oldWeight, sampleIntensity, isMovingObject, oldIdx);
+#else
+
+                          ao = ssao(IN, colors, noiseTex, samples,
+                                      normal, eyeSpacePos.xyz, radiusMult, bl, 
+                                          br, tl, tr, normalize(viewDir), 
+                                          oldWeight, sampleIntensity, isMovingObject, oldIdx,
+                                          attribsTex);
+#endif                            
                 }
                 else
                 {
-                        ao = ssao2(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, radiusMult, 
+                        /*ao = ssao2(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, radiusMult, 
                                    bl, br, tl, tr, normalize(viewDir), oldWeight, sampleIntensity, 
                                            isMovingObject, normals, oldIdx);
+                                           */
                 }
         }
@@ -575 +740 @@
         
         // don't check for moving objects, otherwise almost no coherence
-        if (!isMovingObject)
+        if (1)//!isMovingObject)
         {
                 if (ao.y > completelyResetThres) 
@@ -584 +749 @@
                 else if (ao.y > partlyResetThres)
                 {
-                        oldWeight = min(oldWeight, 4.0f * newWeight);
+                        const float factor = 4.0f;
+                        oldWeight = min(oldWeight, factor * newWeight);
                         //oldWeight = .0f; 
                         //oldIdx    = .0f;
@@ -594 +760 @@
         //-- blend ao between old and new samples (and avoid division by zero)
 
-        OUT.illum_col.x = (ao.x * newWeight + oldSsao * oldWeight);
+        OUT.illum_col.x = ao.x * newWeight + oldSsao * oldWeight;
         OUT.illum_col.x /= (newWeight + oldWeight);
+        //OUT.illum_col.x = clamp(OUT.illum_col.x, 0, 1);
+        //OUT.illum_col.x = ao.y;
 
         // the new weight for the next frame