cook-torrance_fs.glsl

Go to the documentation of this file.

/**
 * @file
 * @brief A fragment shader model for light reflection.
 *
 * The Cook-Torrance model for light reflection is a physics
 * based model which uses two "roughness" parameters to describe
 * the shape and distribution of micro-facets on the surface.
 * NOTE: portions based on D3D9 source from Jack Hoxley
 */

#define ATTENUATE_THRESH 0.005

/**
 * @todo does not compile on my ati x600 yet
 */
vec3 LightContribution(in vec4 lightParams, in vec3 lightDir, in vec3 N, in vec3 V, float NdotV, float R_2, in vec4 roughness, in vec4 specular, in vec4 diffuse) {
   /* calculate light attenuation due to distance (do this first so we can return early if possible) */
   float attenuate = 1.0;

   float dist = length(lightDir);
   float attenDiv = lightParams.a * dist * dist;
   /* If none of the attenuation parameters are set, we keep 1.0.*/
   if (bool(attenDiv)) {
       attenuate = 1.0 / attenDiv;
   }

   /* if we're out of range, ignore the light; else calculate its contribution */
   if (attenuate < ATTENUATE_THRESH) {
       return vec3(0.0);
   }

   /* Normalize vectors and cache dot products */
   vec3 L = normalize(lightDir);
   float NdotL = clamp(dot(N, L), 0.0, 1.0);

   /* Compute the final color contribution of the light */
   vec3 diffuseColor = diffuse.rgb * lightParams.rgb * NdotL;
   vec3 specularColor = lightParams.rgb;

   /* Cook-Torrance shading */
   if (ROUGHMAP > 0) {
       vec3 H = normalize(-L + V);
       float NdotH = dot(N, -H);
       float VdotH = dot(V, H);
       float NdotH_2 = NdotH * NdotH;

       /* Compute the geometric term for specularity */
       float G1 = (2.0 * NdotH * NdotV) / VdotH;
       float G2 = (2.0 * NdotH * NdotL) / VdotH;
       float G = clamp(min(G1, G2), 0.0, 1.0);

       /* Compute the roughness term for specularity */
       float A = 1.0 / (4.0 * R_2 * NdotH_2 * NdotH_2);
       float B = exp((NdotH_2 - 1.0) / (R_2 * NdotH_2));
       float R = A * B;

       /* Compute the fresnel term for specularity using Schlick's approximation*/
       float F = roughness.g + (1.0 - roughness.g) * pow(1.0 - VdotH, 5.0);

       specularColor *= specular.rgb * roughness.b * NdotL * (F * R * G) / (NdotV * NdotL);
   } else { /* Phong shading */
       specularColor *= specular.rgb * pow(max(dot(V, reflect(L, N)), 0.0), specular.a);
   }

   /* @note We attenuate light here, but attenuation doesn't affect "directional" sources like the sun */
   return (attenuate * (max(diffuseColor, 0.0) + max(specularColor, 0.0)));
}


vec4 IlluminateFragment(void) {
   vec3 totalColor= vec3(0.0);

   /* sample the relevant textures */
   vec2 coords = gl_TexCoord[0].st;
   vec2 offset = vec2(0.0);

   /* do per-fragment calculations */
   vec3 V = -normalize(eyedir);
   vec3 N = vec3(0.0, 0.0, 1.0); /* basic surface normal */

#if r_bumpmap
   if (BUMPMAP > 0) {
       vec4 normalMap = texture2D(SAMPLER_NORMALMAP, coords);
       N = normalize(normalMap.xyz * 2.0 - 1.0);
       N.xy *= BUMP;
       if (PARALLAX > 0.0) {
           offset = BumpTexcoord(normalMap.a);
           coords += offset;
       }
   }
#endif

   vec4 diffuse = texture2D(SAMPLER_DIFFUSE, coords);
   vec4 specular;
   if (SPECULARMAP > 0) {
       specular = texture2D(SAMPLER_SPECULAR, coords);
   } else {
       specular = vec4(HARDNESS, HARDNESS, HARDNESS, SPECULAR);
   }
   specular.a *= 512.0;

   vec4 roughness;
   float R_2 = 0.0;
   float NdotV = 0.0;
   if (ROUGHMAP > 0) {
       roughness = texture2D(SAMPLER_ROUGHMAP, coords);
       /* scale reflectance to a more useful range */
       roughness.r = clamp(roughness.r, 0.05, 0.95);
       roughness.g *= 3.0;
       R_2 = roughness.r * roughness.r;
       NdotV = dot(N, -V);
   } else {
       roughness = vec4(0.0);
   }

   /* add ambient light */
   totalColor += diffuse.rgb * AMBIENT;

   /* fake light for the sunlight */
   vec4 sunColor;
   sunColor.rgb = SUNCOLOR;
   sunColor.a = 1.0;
   totalColor += LightContribution(sunColor, sunDir, N, V, NdotV, R_2, roughness, specular, diffuse);

   /* do per-light calculations */
#unroll r_dynamic_lights
   totalColor += LightContribution(LIGHTPARAMS[$], lightDirs[$], N, V, NdotV, R_2, roughness, specular, diffuse);
#endunroll

   return vec4(totalColor, diffuse.a);
}