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

Timestamp:

12/08/08 03:01:45 (16 years ago)

Author:

mattausch

Message:

lense flare starting to work

Location:

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

Files:

• common.h (modified) (2 diffs)
• lenseFlare.cg (modified) (1 diff)
• ssao.cg (modified) (5 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/common.h

@@ +1 @@
+/************************************/
+/*     Common shader functions      */
+/************************************/
+
+/** Interpolate bilinearly between 2 vectors
+*/
 inline float3 Interpol(float2 w, float3 bl, float3 br, float3 tl, float3 tr)
 {
@@ -9 +15 @@
 
 
-// reconstruct world space position
+/** reconstruct world space position
+*/
 inline float3 ReconstructSamplePos(uniform sampler2D tex,
                                                                    float2 texcoord, 

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

@@ -6 +6 @@
 };
 
-float4 main(fragment IN, 
-                        uniform sampler2D colors,
-                        uniform sampler2D ,
-                        ): COLOR
+
+
+float4 LenseFlare(fragment IN, 
+                                  uniform sampler2D colorsTex,
+                                  uniform sampler2D flareTex1,
+                                  uniform sampler2D flareTex2,
+                                  uniform sampler2D flareTex3,
+                                  uniform sampler2D flareTex4,
+                                  uniform float2 vectorToLight, // vector to current light position
+                                  uniform float distanceToLight // distance to current light position
+                                  ): COLOR
 {
         // center color
-        const float4 centerColor = tex2Dlod(colors, float4(IN.texCoords, 0, 0));
-        // center depth
-        const float4 centerDepth = float4(centerColor.w);
+        const float4 color = tex2Dlod(colorsTex, float4(IN.texCoords, 0, 0));
         
-        const float2 lt = IN.texCoords + offsets[0];
-        const float2 rb = IN.texCoords + offsets[1];
-        const float2 rt = IN.texCoords + offsets[2];
-        const float2 lb = IN.texCoords + offsets[3];
+        const float scale = 0.5f;
+        const float center = float2(.5f, .5f);
+        const float2 newPos = vectorToLight * distanceToLight;
 
+        const float2 newTexCoords = (IN.texCoords - center) / scale + center - newPos;
 
-        return col;
+        const float4 flare1 = tex2Dlod(flareTex1, float4(newTexCoords, 0, 0));
+
+        float4 result;
+
+        result.w = color.w;
+
+        //const float factor = 0.9f;
+        //result.xyz = lerp(color.xyz, flare1.xyz, factor);
+        //result.xyz = color.xyz * (1.0f - flare1.w) + flare1.xyz * flare1.w;
+        result.xyz = color.xyz + flare1.xyz;
+
+        return result;
 }

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

@@ -258 +258 @@
                         float3 viewDir,
                         float newWeight,
-                        float sampleIntensity
+                        float sampleIntensity,
+                        bool isMovingObject
                         )
 {
@@ -312 +313 @@
 
                 ++ numSamples;
-                
+
                 // check if the samples have been valid in the last frame
-                // only mark sample as invalid if taking it into account can have influence the ssao:
-                // hence we also check if the sample or the same sample in the previous frame
-                // had any chance to be near the current sample
+                // only mark sample as invalid if in the last / current frame
+                // they possibly have any influence on the ao
                 const float changeFactor = sampleColor.y;
                 const float pixelValid = sampleColor.x;
 
-                // hack: cedistance measure can fail in some cases => choose something different
+                // we check if the sample could have been near enough to the current pixel 
+                // to have any influence in the current or last frame
                 const float tooFarAway = step(0.5f, lengthToSample - changeFactor);
                 validSamples = max(validSamples, (1.0f - tooFarAway) * pixelValid);
-                //validSamples += sampleColor.x;
-
-                //if ((validSamples < 1.0f) && (newWeight > 200) && (numSamples >= 8)) break;
-                //if ((validSamples < 1.0f) && (numSamples >= 8)) break;
-        }
-
+
+#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 >= 8)
+                {
+                        // if the pixel belongs to a static object and all the samples stay valid in the current frame
+                        if (!isMovingObject && (validSamples < 1.0f)) 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 && (newWeight > NUM_SAMPLES * 5)) break;
+                }
+#endif
+
+        }
+
+        // scale ao contribution
         total_ao /= numSamples;
 
-        return float3(max(0.0f, 1.0f - total_ao), validSamples, numSamples);
+        return float3(total_ao, validSamples, numSamples);
 }
 
@@ -382 +394 @@
         float scaleFactor = kernelRadius * invw;
 
+        const float sqrMoveSpeed = SqrLen(diffVec);
+        const bool isMovingObject = (sqrMoveSpeed > DYNAMIC_OBJECTS_THRESHOLD);
+
         
         /////////////////
@@ -403 +418 @@
         if (eyeSpaceDepth < 1e10f)
         {
-                ao = ssao(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, scaleFactor, bl, br, tl, tr, normalize(viewDir), oldWeight, sampleIntensity);
+                ao = ssao(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, scaleFactor, bl, br, tl, tr, normalize(viewDir), oldWeight, sampleIntensity, isMovingObject);
                 //ao = ssao2(IN, colors, noiseTex, samples, normal, eyeSpacePos.xyz, scaleFactor, bl, br, tl, tr, normalize(viewDir), normals, sampleIntensity);
         }
@@ -411 +426 @@
         }
 
-        const float squaredLen = SqrLen(diffVec);
-
-        // check if we have to reset pixel because one of the sample points was invalid
-        if (squaredLen < DYNAMIC_OBJECTS_THRESHOLD)
-        {
-                if (ao.y > 4.0f) 
-                        oldWeight = 0; 
-                else if (ao.y > 1.0f)
-                        oldWeight = min(oldWeight, 4.0f * NUM_SAMPLES);
-        }
-
+        
+        ///////////
+        //-- check if we have to reset pixel because one of the sample points was invalid
+        //-- only do this if the current pixel does not belong to a moving object
+
+        // the weight equals the number of sampled shot in this pass
         const float newWeight = ao.z;
+
+        const float completelyResetThres = 4.0f;
+        const float partlyResetThres = 1.0f;
+        
+        if (!isMovingObject)
+        {
+                if (ao.y > completelyResetThres) 
+                        oldWeight = .0f; 
+                else if (ao.y > partlyResetThres)
+                        oldWeight = min(oldWeight, 4.0f * newWeight);
+        }
+
+        // the new weight for the next frame
         const float combinedWeight = clamp(newWeight + oldWeight, .0f, temporalCoherence);
 
-        
-        // blend between old and new samples (and avoid division by zero)
+        //////////
+        //-- blend ao between old and new samples (and avoid division by zero)
         OUT.illum_col.x = (ao.x * newWeight + oldSsao * oldWeight) / max(1e-6f, newWeight + oldWeight);
+
         OUT.illum_col.z = SqrLen(diffVec);
         OUT.illum_col.y = combinedWeight;