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

#define SAMPLES 24

// kustls magic sample positions
static const float2 samples[SAMPLES] =
{
  {-0.326212f, -0.405805f},
  {-0.840144f, -0.07358f},
  {-0.695914f, 0.457137f},
  {-0.203345f, 0.620716},
  {0.96234f, -0.194983f},
  {0.473434f, -0.480026f},
  {0.519456, 0.767022f},
  {0.185461f, -0.893124f},
  {0.507431f, 0.064425f},
  {0.89642f, 0.412458f},
  {-0.32194f, -0.932615f},
  {-0.791559f, -0.597705f},
  {0.326212f, 0.405805f},
  {0.840144f, 0.07358f},
  {0.695914f, -0.457137f},
  {0.203345f, -0.620716},
  {-0.96234f, 0.194983f},
  {-0.473434f, 0.480026f},
  {-0.519456, -0.767022f},
  {-0.185461f, 0.893124f},
  {-0.507431f, -0.064425f},
  {-0.89642f, -0.412458f},
  {0.32194f, 0.932615f},
  {0.791559f, 0.597705f}
};


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


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;
}


//based on kustls shader        
float ssao(fragment IN,
           uniform sampler2D positions,
           uniform sampler2D normals,
           uniform sampler2D noiseTexture                               
           )
{
  // the current world position
  float4 centerPosition = tex2D(positions, IN.texCoord.xy);
  // the w coordinate from the persp. projection
  float w = centerPosition.w;

  // the normal on the current position
  float3 centerNormal = tex2D(normals, IN.texCoord.xy).xyz;
  //normalize(centerNormal);
  
  // 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 < SAMPLES; i ++) {
    float2 offset = samples[i];
    
    //sample noisetex; r stores costheta, g stores sintheta
    float3 noise = tex2D(noiseTexture, IN.texCoord.xy).xyz * 2.0f - 1.0f;
        
    // rotation
    //float2 offsetTransformed = offset;
    float2 offsetTransformed;
    offsetTransformed.x = noise.r * offset.x - noise.g * offset.y;
    offsetTransformed.y = noise.g * offset.x + noise.r * offset.y;
                
    // weight with projected coordinate to reach similar kernel size for near and far
    float2 texcoord = IN.texCoord.xy + offsetTransformed * areaSize * 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 + 1e-9f);
    
    // Angle between current normal and direction to sample controls AO intensity.
    float cos_angle = dot(direction_to_sample, centerNormal);
    cos_angle = max(cos_angle, 0.0f);
    
    // distance between current position and sample position controls AO intensity.
    const float maxdist = 5e-1f;
    //const float scale = 50.0f;

    float distance_intensity = maxdist - length_to_sample;
    distance_intensity *= distance_intensity;
    distance_intensity = max(distance_intensity, 0.0f);
    
    total_ao += cos_angle * sampleIntensity * distance_intensity;
  }
        
  return (1.0f - total_ao);
}


pixel main(fragment IN, 
           uniform sampler2D colors,
           uniform sampler2D positions,
           uniform sampler2D normals,
           uniform sampler2D noiseTexture)
{
  pixel OUT;

  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);
  float3 normal = tex2D(normals, IN.texCoord.xy).xyz;

  // expand normal
  normal = normalize(normal * 2.0f - 1.0f);

  float4 position = tex2D(positions, IN.texCoord.xy);

  float4 ambient = float4(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 ao = ssao(IN, positions, normals, noiseTexture);
  float ao = 1.0f;
  //OUT.color = ao; 
  OUT.color = ao * (ambient + diffuse) * color;
  //OUT.color = (ambient + diffuse) * color;
      
  return OUT;
}