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

Timestamp:

08/26/08 16:27:11 (16 years ago)

Author:

mattausch

Message:

changed ssao to multipass algorithm

File:

• GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/ssao.cg (modified) (2 diffs)

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

@@ +1 @@
+////////////////////
+// Screen Spaced Ambient Occlusion shader
+// based on shader of Alexander Kusternig
+
+//#define NUM_SAMPLES 8
+#define NUM_SAMPLES 16
+
+// rule of thumb: approx 1 / NUM_SAMPLES
+#define SAMPLE_INTENSITY 0.15
+//#define SAMPLE_INTENSITY 0.125f
+
+#define AREA_SIZE 9e-1f
+//#define VIEW_CORRECTION_SCALE 0.3f
+#define VIEW_CORRECTION_SCALE 0.5f
+#define DISTANCE_SCALE 1e-6f
+
+
 struct fragment
 {
-    float4 pos: WPOS; // normalized screen position
-    float4 view: COLOR;
-    float4 texcoord: TEXCOORD0;      
-    float4 lindepth: TEXCOORD1;
+         // normalized screen position
+        float4 pos: WPOS;
+        float4 texCoord: TEXCOORD0; 
+        float3 view: COLOR0;
 };
 
@@ -10 +27 @@
 struct pixel
 {
-    float4 col: COLOR0;
+        float4 color: COLOR0;
 };
 
 
-float3 reflect(float3 pt, float3 n)
+float2 reflect(float2 pt, float2 n)
 {
   // distance to plane
   float d = dot(n, pt);
   // reflect around plane
-  float3 rpt = pt - d * 2.0f * n;
-  
-  //return pt;
+  float2 rpt = pt - d * 2.0f * n;
+
   return rpt;
 }
 
 
+float2 rotate(float2 pt, float2 n)
+{
+        float2 ptTransformed;
+        ptTransformed.x = n.r * pt.x - n.g * pt.y;
+        ptTransformed.y = n.g * pt.x + n.r * pt.y;
+
+        return ptTransformed;
+}
+
+
+/** The ssao shader returning the an intensity value between 0 and 1
+*/
+float ssao(fragment IN,
+                   uniform sampler2D positions,
+                   uniform sampler2D noiseTexture,
+                   uniform float2 samples[NUM_SAMPLES],
+                   uniform float3 currentNormal,
+                   uniform float3 currentViewDir,
+                   uniform float noiseMultiplier,
+                   uniform float4 centerPosition
+                   )
+{
+        // the w coordinate from the persp. projection
+        float w = centerPosition.w;
+
+        // Check in a circular area around the current position.
+        // Shoot vectors to the positions there, and check the angle to these positions.
+        // Summing up these angles gives an estimation of the occlusion at the current position.
+
+        float total_ao = 0.0;
+
+        const float areaSize = 5e-1f;
+
+        for (int i = 0; i < NUM_SAMPLES; i ++) 
+        {
+                float2 offset = samples[i];
+
+                //sample noisetex; r stores costheta, g stores sintheta
+                //float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy * 2.0f - 1.0f;
+                float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy;
+
+                // rotation
+                //float2 offsetTransformed = offset;
+                //float2 offsetTransformed = rotate(offset, mynoise);
+                float2 offsetTransformed = reflect(offset, mynoise);
+
+                // weight with projected coordinate to reach similar kernel size for near and far
+                float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w;
+
+                // sample downsampled texture in order to speed up texture accesses
+                float3 sample_position = tex2Dlod(positions, float4(texcoord, 0, 1)).xyz;
+                //float3 sample_position = tex2D(positions, texcoord).xyz;
+
+                float3 vector_to_sample = sample_position - centerPosition.xyz;
+                float length_to_sample = length(vector_to_sample);
+                float3 direction_to_sample = vector_to_sample / length_to_sample;
+
+                // Angle between current normal and direction to sample controls AO intensity.
+                float cos_angle = dot(direction_to_sample, currentNormal);
+                cos_angle = max(cos_angle, 0.0f);
+
+                // distance between current position and sample position controls AO intensity.
+                float distance_intensity = 
+                        (SAMPLE_INTENSITY * DISTANCE_SCALE) / (DISTANCE_SCALE + length_to_sample * length_to_sample);
+
+                // if surface normal perpenticular to view dir, some samples probably count less 
+                // => compensate for this
+                float view_correction = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal));
+
+                total_ao += cos_angle * distance_intensity * view_correction;
+        }
+
+        return (1.0f - total_ao);
+        //return dot(currentViewDir, currentNormal);
+}
+
+
+/** Computes ambient occlusion + diffuse reflections
+*/
+float4 globIllum(fragment IN,
+                                 uniform sampler2D colors,
+                                 uniform sampler2D positions,
+                                 uniform sampler2D noiseTexture,
+                                 uniform float2 samples[NUM_SAMPLES],
+                                 uniform float3 currentNormal,
+                                 uniform float3 currentViewDir,
+                                 uniform float noiseMultiplier,
+                                 uniform float4 centerPosition
+                                 )
+{
+        // the w coordinate from the persp. projection
+        float w = centerPosition.w;
+
+        // Check in a circular area around the current position.
+        // Shoot vectors to the positions there, and check the angle to these positions.
+        // Summing up these angles gives an estimation of the occlusion at the current position.
+
+        float total_ao = 0.0;
+        float3 total_color = float3(0.0f);
+
+        const float areaSize = 5e-1f;
+
+        for (int i = 0; i < NUM_SAMPLES; i ++) 
+        {
+                float2 offset = samples[i];
+
+                //sample noisetex; r stores costheta, g stores sintheta
+                float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy * 2.0f - 1.0f;
+
+                // rotation
+                float2 offsetTransformed = rotate(offset, mynoise);
+
+                // weight with projected coordinate to reach similar kernel size for near and far
+                float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w;
+
+                float3 sample_position = tex2D(positions, texcoord).xyz;
+                float3 sample_color = tex2D(colors, texcoord).xyz;
+
+                float3 vector_to_sample = sample_position - centerPosition.xyz;
+                float length_to_sample = length(vector_to_sample);
+                float3 direction_to_sample = vector_to_sample / length_to_sample;
+
+                // Angle between current normal and direction to sample controls AO intensity.
+                float cos_angle = dot(direction_to_sample, currentNormal);
+                cos_angle = max(cos_angle, 0.0f);
+
+                // distance between current position and sample position controls AO intensity.
+                float distance_intensity = 
+                        (SAMPLE_INTENSITY * DISTANCE_SCALE) / (DISTANCE_SCALE + length_to_sample * length_to_sample);
+
+                // if normal perpenticular to view dir, only half of the samples count
+                float view_correction = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal));
+
+                total_ao += cos_angle * distance_intensity * view_correction;
+                total_color += cos_angle * distance_intensity * view_correction * sample_color * 0.3f;
+        }
+
+        return float4(total_color, 1.0f - total_ao);
+}
+
+
+/** The mrt shader for screen space ambient occlusion
+*/
 pixel main(fragment IN, 
-           uniform sampler2D lindepth,
-           uniform sampler2D scene,
-           uniform sampler2D normal,
-           uniform float invTexSize,
-           uniform float radius,
-           uniform float3 eyevec,
-           uniform float3 samples[32])
-{
-    pixel OUT;
+                   uniform sampler2D colors,
+                   uniform sampler2D positions,
+                   uniform sampler2D normals,
+                   uniform sampler2D noiseTexture,
+                   uniform float2 samples[NUM_SAMPLES],
+                   uniform float noiseMultiplier,
+                   uniform sampler2D oldTex,
+                   const uniform float4x4 oldModelViewProj,
+                   uniform float maxDepth,
+                   uniform float expFactor
+                   )
+{
+        pixel OUT;
+
+        float4 normal = tex2D(normals, IN.texCoord.xy);
+        
+        // the ambient term
+        float amb = normal.w;
+
+        // expand normal
+        normal = normalize(normal);// * 2.0f - 1.0f);
+        /// the current view direction
+        float3 viewDir = normalize(IN.view * 2.0f - float3(1.0f));
+
+        // the current world position
+        float4 centerPosition = tex2D(positions, IN.texCoord.xy);
+        
+        float4 col = tex2D(colors, IN.texCoord.xy);
+        float currentDepth = col.w;
+
+        float ao = ssao(IN, positions, noiseTexture, samples, normal.xyz, viewDir, noiseMultiplier, centerPosition);
+        float4 attenuated_color = ao * col;
+        //float4 attenuated_color = ao;
+
+        //float4 new_col = globIllum(IN, colors, positions, noiseTexture, samples, normal.xyz, viewDir, noiseMultiplier, centerPosition); 
+        //float4 attenuated_color = ao * col + new_col;
+        
+        const float x = expFactor;
+
+        float4 dummy = centerPosition * maxDepth;
+        dummy.w = 1.0f;
+
+        float4 oldPos = mul(oldModelViewProj, dummy);
+
+        float newDepth = oldPos.z / oldPos.w;
  
-    // eye space z
-    float eyez = tex2D(lindepth, IN.texcoord.xy).x;
-
-    float3 viewvec = IN.view.xyz * 2.0f - float3(1.0f);
-    viewvec /= viewvec.z;
-
-    //return float4(viewvec.xyz, 1.0f);
-    // eye point
-    //float3 eyept = eyez * viewvec;
-    float3 eyept = float3(IN.texcoord.xy, eyez);
-
-    float4 pl = tex2D(normal, IN.pos.xy * invTexSize);
-    pl = pl * 2.0 - float4(1.0);
-
-    float occlusion = 0.0;
-
-    // gather occlusion from surrounding samples
-    for (int i = 0; i < 32; i ++)
-    {
-        // generate new sample point
-        //float3 samplepos = eyept + radius * samples[i];
-        // create some dithering by reflecting the sample point alond some random plane
-        float3 samplepos = eyept + radius * reflect(samples[i], pl.xyz);
-
-        // project to texture space q: why the scaling?
-        float2 sampletex = (samplepos.xy / samplepos.z);// * float2(0.75, 1.0);
-        
-        //float2 sampletexn = sampletex;
-        // normalize to [0 .. 1], move eye point to center
-        //float2 sampletexn = sampletex * 0.5f + float2(0.5f);
-        float2 sampletexn = sampletex + float2(0.5f);
-
-        // look up depth at sample point
-        float depth = tex2D(lindepth, sampletexn).x;
-        // compare: is point occluded?
-        //float zdist = 50.0f * max(-samplepos.z + depth, 0.0f);
-        float zdist = 50.0f * max(samplepos.z - depth, 0.0f);
-        // occlusion factor shrinks quadratic with distance to occluder
-        occlusion += 1.0 / (1.0 + zdist * zdist);
-        //occlusion += 1.0 / (1.0 + zdist);
-   }
-
-   // normalize
-   occlusion /= 32.0f;
-  
-   OUT.col = 1.0f - occlusion;
-   //   OUT.col = tex2D(scene, IN.texcoord.xy) * 0.5 + (1.0f - occlusion);
-
-   return OUT;
-}
+        float2 tex = (oldPos.xy / oldPos.w) * 0.5f + 0.5f;
+        float4 col1 = tex2D(oldTex, tex);
+
+        float oldDepth = col1.w;
+        float depthDif = 1.0f - newDepth / oldDepth;
+
+        if ((tex.x >= 0.0f) && (tex.x < 1.0f) && 
+                (tex.y >= 0.0f) && (tex.y < 1.0f) && 
+                (abs(depthDif)  < 1e-4f))
+        {
+                OUT.color = attenuated_color * expFactor + col1 * float4(1.0f - expFactor);
+        }
+        else
+        {
+                OUT.color = attenuated_color;
+        }
+
+        //OUT.color.xyz = viewDir;
+        //OUT.color = attenuated_color;
+        
+        OUT.color.w = currentDepth;
+
+        return OUT;
+}