src/shaders/shallowwatershader.frag

Go to the documentation of this file.

#version 430

// ===== Uniform Buffers =====

struct LightParam {
    vec3 pos;       
    float isDir;    
    vec3 color;     
    float specExp;  
};

layout(std140, binding = 0) uniform LightInfo 
{
    LightParam lights[2];
};


// ===== Uniforms =====

uniform vec3 camPos;                
uniform vec3 size;                  
uniform float time;                 
uniform float transparency;         
uniform sampler2D terr_texUnit;     
uniform sampler2D height_texUnit;   
uniform samplerCube sky_texUnit;    


// ===== In/Out params =====

in vec3 out_Normal;                 
in vec2 out_TexCoord;               
in vec3 out_ObjPos;                 

out vec4 out_Color;                 


// ===== Variables needed =====

// Light vectors
vec3 r;                             
vec3 s;                             
vec3 eye;                           
vec3 Normal;                        
vec3 re;                            
vec3 right;                         

// Lighting (the Phong model with extras).
float kamb;                         
float kdiff;                        
float ktransr;                      
float ktransg;                      
float ktransb;                      
float krefl;                        
float kblue;                        

vec3 ambLight;                      
vec3 diffLight;                     
vec3 specLight;                     
vec3 reflLight;                     
vec3 surfaceLight;                  
vec3 bottomLight;                   

// Snell's law angles.
float theta1;                       
float theta2;                       

// Underwater triangulation components.
float depth;                        
vec3 displacementDirection;         
float bottomDisplacement1;          
vec3 displacement1;                 
float depthAtDis1;                  
float h;                            
float alpha;                        
float bottomDisplacement2;          
vec3 displacement2;                 
float depthAtDis2;                  
float wdist;                        

vec3 bottomPos;                     
vec3 bottomNormal;                  

// Texture lookups.
vec4 terrainDataUnderSurface;       
vec4 terrainDataAtDis1;             
vec4 terrainDataAtBottom;           
vec4 texDataAtBottom;               
vec3 skyrefl;                       

// Constants
const float waterRefInd = 1.34451;  
const float airRefInd = 1.0;        
const vec3 up = vec3(0.0, 1.0, 0.0);

void main(void)
{
    // eye vector is calculated.
    eye = normalize(camPos - out_ObjPos);

    // Get the normal
    Normal = normalize(out_Normal);

    // Incident and reflected light is calculated for the light source.
    s = normalize(lights[0].pos - (1 - lights[0].isDir) * out_ObjPos);
    r = normalize(2 * Normal * dot(s, Normal) - s);

    right = cross(Normal, eye);
    // Snell's law
    // Since asin is not that cheap, approximations could be made here.
    theta1 = asin(length(right));
    theta2 = asin(airRefInd * sin(theta1) / waterRefInd);

    // Texture lookup at fragment.
    terrainDataUnderSurface = texture(height_texUnit, out_TexCoord);

    // Depth at fragment.
    depth = out_ObjPos.y - size.y * terrainDataUnderSurface.a;
    
    if (depth < 0 || out_ObjPos.z < 1 || out_ObjPos.x < 1 )
    {
        discard;
    }

    // To find the fragment at the bottom corresponding to what would be seen after refraction
    // at the water surface, a crude displacement approximation in the xz-plane from the surface
    // fragment to the approximated fragment at the bottom is calculated.
    vec3 s2 = airRefInd / waterRefInd * cross(Normal, cross(Normal, eye)) - Normal * sqrt(1 - pow(airRefInd / waterRefInd, 2) * dot(cross(Normal, eye), cross(Normal, eye)));
    displacementDirection = normalize(s2 - dot(s2, -up) * -up);
    bottomDisplacement1 = tan(theta2) * depth;
    displacement1 = bottomDisplacement1 * displacementDirection;

    // Texture lookup at approximation.
    terrainDataAtDis1 = texture(height_texUnit, out_TexCoord + vec2(displacement1.x / size.x, displacement1.z / size.z));

    // "Depth" at approximation.
    depthAtDis1 = out_ObjPos.y - size.y * terrainDataAtDis1.a;
    // Height at approximation (y distance from fragment bottom to approximation bottom).
    h = depth - depthAtDis1;
    // To minimize visual errors caused by irregular terrain, a better approximation is made.
    alpha = abs(atan(h / bottomDisplacement1));
    bottomDisplacement2 = cos(alpha) * depth * sin(theta2) / cos(alpha - theta2);
    displacement2 = bottomDisplacement2 * displacementDirection;

    // Texture lookups at better approximation.
    terrainDataAtBottom = texture(height_texUnit, out_TexCoord + vec2(displacement2.x / size.x, displacement2.z / size.z));
    texDataAtBottom = texture(terr_texUnit, out_TexCoord + vec2(displacement2.x / size.x, displacement2.z / size.z));
    // "Depth" at better approximation.
    depthAtDis2 = out_ObjPos.y - size.y * terrainDataAtBottom.a;

    // Coordinates and normal of seen position of bottom.
    bottomPos = out_ObjPos + displacement2 - vec3(0, depthAtDis2, 0);
    bottomNormal = normalize(terrainDataAtBottom.rgb);

    // Distance from surface to seen position of bottom.
    wdist = length(bottomPos - out_ObjPos);
    
    // Skybox reflection.
    // Reflected eye vector.
    re = 2 * dot(eye, Normal) * Normal - eye;
    skyrefl = texture(sky_texUnit, re).rgb;
    // Light components, water surface.
    kamb = 0.1;
    krefl = clamp((1 - eye.y), 0.2, 0.7);
    // Ambient light.
    ambLight = kamb * vec3(1.0, 1.0, 1.0);
    reflLight = vec3(0.0, 0.0, 0.0);
    // Reflected light.
    reflLight += krefl * skyrefl;
    
    surfaceLight = vec3(0.0, 0.0, 0.0);
    // The light components are added to the total surface light.
    surfaceLight += ambLight;
    surfaceLight += reflLight;

    ktransr = clamp((1 - reflLight.r) * pow((1 + wdist), -1.8 * transparency), 0.0, 0.5);
    ktransg = clamp((1 - reflLight.g) * pow((1 + wdist), -1.7 * transparency), 0.0, 0.5);
    ktransb = clamp((1 - reflLight.b) * pow((1 + wdist), -1.5 * transparency), 0.0, 0.5);
    kblue = 1 - eye.y;

    // Calculating bottom light.
    // Phong shading for the bottom.
    s = normalize(lights[1].pos - (1 - lights[1].isDir) * bottomPos);
    r = normalize(2 * bottomNormal * dot(s, bottomNormal) - s);

    // eye vector is calculated (note: from bottom to surface, not to camera).
    eye = normalize(out_ObjPos - bottomPos);

    // Light according to the Phong model.
    kamb = 0.1;
    kdiff = 0.5;
    krefl = 0.5;
    ambLight = kamb * vec3(1.0, 1.0, 1.0);
    diffLight = vec3(0.0, 0.0, 0.0);
    specLight = vec3(0.0, 0.0, 0.0);
    // Diffuse light.
    diffLight += kdiff * lights[1].color * max(0.0, dot(s, bottomNormal));
    // Specular light.
    specLight += krefl * lights[1].color * max(0.0, pow(dot(r, eye), lights[1].specExp));

    bottomLight = vec3(0.0, 0.0, 0.0);
    // The light components are added to the total bottom light.
    bottomLight += ambLight;
    bottomLight += diffLight;
    bottomLight += specLight;
    
    bottomLight *= texDataAtBottom.rgb;
    //Color dependant attenuation.
    bottomLight = vec3(bottomLight.r * ktransr, bottomLight.g * ktransg, bottomLight.b * ktransb);

    if (out_ObjPos.y > 35.0f || out_ObjPos.y < 0.000000005f) {
        vec3 brown = vec3(250, 184,173);
        brown = 0.3*normalize(brown);
        out_Color = vec4(brown,1);
    }
    else{
        out_Color = vec4(bottomLight + surfaceLight, 1.0);
    }
}