geoscape_fs.glsl

Go to the documentation of this file.

/**
 * @file
 * @brief Geoscape fragment shader.
 */
 
#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
 
in_qualifier vec2 tex;
 
in_qualifier vec4 ambientLight;
in_qualifier vec4 diffuseLight;
in_qualifier vec4 specularLight;
in_qualifier vec4 diffuseLight2;
 
in_qualifier vec3 lightVec;
in_qualifier vec3 lightVec2;
in_qualifier vec3 eyeVec;
 
#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
 
/** Diffuse.*/
uniform sampler2D SAMPLER_DIFFUSE;
/** Blend.*/
uniform sampler2D SAMPLER_BLEND;
/** Normalmap.*/
uniform sampler2D SAMPLER_NORMALMAP;
 
uniform float BLENDSCALE;
uniform float GLOWSCALE;
uniform vec4 DEFAULTCOLOR;
uniform vec4 CITYLIGHTCOLOR;
 
const float specularExp = 32.0;
 
/* index of refraction for water */
const float n1 = 1.0;
const float n2 = 1.333;
const float eta = n1 / n2;
 
/**
 * @brief Calculate reflection component of Frenel's equations.
 */
float fresnelReflect(in float cos_a) {
    float cos_b = sqrt(1.0 - ((eta * eta) * ( 1.0 - (cos_a * cos_a))));
    float rs = (n1 * cos_a - n2 * cos_b ) / (n1 * cos_a + n2 * cos_b);
    float rp = (n1 * cos_b - n2 * cos_a ) / (n1 * cos_b + n2 * cos_a);
    return ((rs * rs + rp * rp) / 2.0);
}
 
 
void main(void) {
    /* blend textures smoothly */
    vec3 diffuseColorA = texture2D(SAMPLER_DIFFUSE, tex).rgb;
    vec3 diffuseColorB = texture2D(SAMPLER_BLEND, tex).rgb;
    vec4 diffuseColor;
    diffuseColor.rgb = ((1.0 - BLENDSCALE) * diffuseColorA) + (BLENDSCALE * diffuseColorB);
    diffuseColor.a = 1.0;
 
    /* calculate diffuse reflections */
    vec3 V = normalize(eyeVec);
    vec3 L = normalize(lightVec);
    vec3 N = normalize(texture2D(SAMPLER_NORMALMAP, tex).rgb * 2.0 - 1.0);
    float NdotL = clamp(dot(N, L), 0.0, 1.0);
    vec4 reflectColor = diffuseColor * diffuseLight * NdotL;
 
    /* calculate specular reflections */
    float RdotL = clamp(dot(reflect(-L, N), V), 0.0, 1.0);
    float gloss = texture2D(SAMPLER_NORMALMAP, tex).a;
    /* NOTE: this "d" here is a hack to compensate for the fact
     * that we're using orthographic projection.
     */
    float d = clamp(pow(1.0 + dot(V, L), 0.4), 0.0, 1.0);
    float fresnel = 2.0 * fresnelReflect(NdotL);
    vec4 specularColor = (d * d * fresnel * fresnel) * gloss * pow(RdotL, specularExp) * specularLight;
 
    /* calculate night illumination */
    float diffuseNightColor = texture2D(SAMPLER_DIFFUSE, tex).a;
    float NdotL2 = clamp(dot(N, normalize(lightVec2)), 0.0, 1.0);
    vec4 nightColor = diffuseLight2 * CITYLIGHTCOLOR * diffuseNightColor * NdotL2;
 
    vec4 color = DEFAULTCOLOR + (ambientLight * diffuseColor) + reflectColor + (0.0 * specularColor) + nightColor;
    vec4 hdrColor = GLOWSCALE *
                    ( clamp((reflectColor - vec4(0.9, 0.9, 0.9, 0)), 0.0, GLOWSCALE) +
                      1.0 * specularColor + nightColor);
    hdrColor.a = 1.0;
 
    /* calculate final color */
#if r_postprocess
    gl_FragData[0] = color;
    gl_FragData[1] = hdrColor;
#else
    gl_FragColor.rgb = color.rgb + hdrColor.rgb;
    gl_FragColor.a = color.a;
#endif
}