atmosphere_fs.glsl

Go to the documentation of this file.

/**
 * @file
 * @brief Atmosphere fragment shader.
 */
 
/*
 * Indicates that gl_FragData is written to, not gl_FragColor.
 * #extension needs to be placed before all non preprocessor code.
 */
#if r_postprocess
    /*
     * Indicates that gl_FragData is written to, not gl_FragColor.
     * #extension needs to be placed before all non preprocessor code.
     */
    #extension GL_ARB_draw_buffers : enable
#endif
 
#ifndef glsl110
    #if r_postprocess
        /** After glsl1110 this need to be explicitly declared; used by fixed functionality at the end of the OpenGL pipeline.*/
        out vec4 gl_FragData[2];
    #else
        /** After glsl1110 this need to be explicitly declared; used by fixed functionality at the end of the OpenGL pipeline.*/
        out vec4 gl_FragColor;
    #endif
#endif
 
 
in_qualifier vec2 tex;
 
in_qualifier vec4 ambientLight;
in_qualifier vec4 diffuseLight;
in_qualifier vec4 specularLight;
 
in_qualifier vec3 lightVec;
in_qualifier vec3 eyeVec;
 
/** Diffuse.*/
uniform sampler2D SAMPLER_DIFFUSE;
/** Normalmap.*/
uniform sampler2D SAMPLER_NORMALMAP;
 
uniform float GLOWSCALE;
uniform vec4 DEFAULTCOLOR;
 
const float specularExp = 32.0;
 
/**
 * @brief Fresnel's equations for reflection and refraction between different density media.
 */
void fresnelRefract(vec3 L, vec3 N, float n1, float n2,
    out vec3 reflection, out vec3 refraction,
    out float reflectance, out float transmittance) {
 
    float eta = n1/n2;
    float cos_theta1 = dot(L, N);
    float cos_theta2 = sqrt(1.0 - ((eta * eta) * ( 1.0 - (cos_theta1 * cos_theta1))));
    reflection = L - 2.0 * cos_theta1 * N;
    refraction = (eta * L) + (cos_theta2 - eta * cos_theta1) * N;
    float rs = (n1 * cos_theta1 - n2 * cos_theta2 ) / (n1 * cos_theta1 + n2 * cos_theta2);
    float rp = (n1 * cos_theta2 - n2 * cos_theta1 ) / (n1 * cos_theta2 + n2 * cos_theta1);
    reflectance = (rs * rs + rp * rp) / 2.0;
    transmittance = ((1.0-rs) * (1.0-rs) + (1.0-rp) * (1.0-rp)) / 2.0;
}
 
void main() {
    vec3 diffuseColor = texture2D(SAMPLER_DIFFUSE, tex).rgb;
    vec3 V = normalize(eyeVec).rgb;
    vec3 L = normalize(lightVec).rgb;
    vec3 N = normalize(texture2D(SAMPLER_NORMALMAP, tex).rgb * 2.0 - 1.0);
    /* calculate reflections/refractions */
    vec3 Rvec;
    vec3 Tvec;
    float R;
    float T;
    fresnelRefract(L, N, 1.0, 1.133, Rvec, Tvec, R, T);
 
    float RdotV = clamp(R * dot(Rvec, -V), 0.0, 1.0);
    float TdotV = clamp(T * ((dot(Tvec, -V) + 1.0) / 2.0), 0.0, 1.0);
    float MTdotV = clamp(T * ((dot(-Tvec, -V) + 1.0) / 2.0), 0.0, 1.0);
    float NdotL = clamp(((dot(N, L) + 1.0) / 2.0), 0.0, 1.0);
    float LNdotV = clamp(dot(reflect(-L, N), V), 0.0, 1.0);
    float VdotL = clamp(((dot(L, -V) + 1.0) / 2.0), 0.0, 1.0);
 
    vec3 ambient = vec3(0.05, 0.05, 0.05);
 
    /* calculate reflections */
    vec3 reflectColor = diffuseColor * (ambient + pow(NdotL, 4.0) * (TdotV + MTdotV) + 0.2 * pow(VdotL, 16.0));
 
    float d = clamp(pow(1.0 + dot(V, L), 0.4), 0.0, 1.0);
    vec3 specularColor = d * RdotV * pow(LNdotV, specularExp) * specularLight.rgb;
 
    vec3 hdrColor = GLOWSCALE * (0.4 * reflectColor + 1.0 * specularColor);
 
    /* calculate final color */
#if r_postprocess
    gl_FragData[0] = DEFAULTCOLOR;
    gl_FragData[1].rgb = hdrColor;
    gl_FragData[1].a = 1.0;
#else
    gl_FragColor.rgb = DEFAULTCOLOR.rgb + hdrColor;
    gl_FragColor.a = DEFAULTCOLOR.a;
#endif
}