source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/deferred.cg @ 2833

////////////////////
// Screen Spaced Ambient Occlusion shader
// mainly based on Kustls shader

#define NUM_SAMPLES 8
//#define SAMPLE_INTENSITY 0.5f
//#define SAMPLE_INTENSITY 1.1f
#define SAMPLE_INTENSITY 0.25f
#define AREA_SIZE 5e-1f


struct fragment
{
  float4 pos: WPOS; // normalized screen position
  float4 texCoord: TEXCOORD0; 
  float3 view: COLOR0;
};


struct pixel
{
  float4 color: COLOR0;
};


float2 reflect(float2 pt, float2 n)
{
  // distance to plane
  float d = dot(n, pt);
  // reflect around plane
  float2 rpt = pt - d * 2.0f * n;
  
  //return pt;
  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;
}


//based on kustls shader        
float ssao(fragment IN,
           uniform sampler2D positions,
           uniform sampler2D noiseTexture,
           uniform float2 samples[NUM_SAMPLES],
           uniform float3 currentNormal,
           uniform float3 currentViewDir)
{
  // the current world position
  float4 centerPosition = tex2D(positions, IN.texCoord.xy);
  // 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;
  //const float areaSize = 3e-1f;
  //const float sampleIntensity = 0.2f;
  
  for (int i = 0; i < NUM_SAMPLES; i ++) {
    float2 offset = samples[i];
    
    //sample noisetex; r stores costheta, g stores sintheta
    float2 noise = tex2D(noiseTexture, IN.texCoord.xy * 7.1f).xy * 2.0f - 1.0f;
        
    // rotation
    //float2 offsetTransformed = offset;
    float2 offsetTransformed = rotate(offset, noise);
    //float2 offsetTransformed = reflect(offset, noise);
               
    // 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 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);
    // take quadratic influence to sharpen contrast
    //cos_angle *= cos_angle;

    // distance between current position and sample position controls AO intensity.
    //const float maxdist = 2e-1f;
    //const float maxdist = 5e-1f;
    const float distanceScale = 1e-6f;

    float distance_intensity = 
      (SAMPLE_INTENSITY * distanceScale) / (distanceScale + length_to_sample * length_to_sample);

    // if normal perpenticular to view dir, only half of the samples count
    float view_correction = (2.0f - dot(currentViewDir, currentNormal));

    total_ao += cos_angle * distance_intensity * view_correction;
  }
        
  return (1.0f - total_ao);
}


float4 shade(fragment IN, 
             uniform sampler2D colors,
             uniform sampler2D positions,
             uniform float3 normal,
             uniform float amb)
{
  float4 lightDir = float4(0.8f, -1.0f, 0.7f, 0.0f);
  float4 lightDir2 = float4(-0.5f, 0.5f, 0.4f, 0.0f);
  
  float4 color = tex2D(colors, IN.texCoord.xy);
 
  float4 position = tex2D(positions, IN.texCoord.xy);

  float4 ambient = 0.3f;

  // float3 L = normalize(lightPosition - position);
  float3 light = normalize(lightDir.xyz);
  float3 light2 = normalize(lightDir2.xyz);
 
  float diffuseLight = max(dot(normal, light), 0.0f);
  float diffuseLight2 = max(dot(normal, light2), 0.0f);

  //float diffuse = diffuseLight + diffuseLight2;
  float diffuse = diffuseLight;

  return (ambient + diffuse) * color * (1.0f - amb) + amb * color;
}


pixel main_ssao(fragment IN, 
                uniform sampler2D colors,
                uniform sampler2D positions,
                uniform sampler2D normals,
                uniform sampler2D noiseTexture,
                uniform float2 samples[NUM_SAMPLES])
{
  pixel OUT;

  float4 normal = tex2D(normals, IN.texCoord.xy);
  float amb = normal.w;

  // expand normal
  normal = normalize(normal * 2.0f - 1.0f);
  float3 viewDir = normalize(IN.view * 2.0f - float(1.0f));

  float4 col = shade(IN, colors, positions, normal, amb);
  float ao = ssao(IN, positions, noiseTexture, samples, normal, viewDir);
  
   //OUT.color = ao;
   OUT.color = ao * col; 

  return OUT;
}


pixel main(fragment IN, 
           uniform sampler2D colors,
           uniform sampler2D positions,
           uniform sampler2D normals)
{
  pixel OUT;
  
  float4 normal = tex2D(normals, IN.texCoord.xy);
  float amb = normal.w;

  //OUT.color.xyz = IN.view;
  // expand normal
  normal = normalize(normal * 2.0f - float4(1.0f));
  
  float4 col = shade(IN, colors, positions, normal.xyz, amb);
  OUT.color = col;

  return OUT;
}