RealisicWater-GLSL

#version 130
uniform vec4 g_vec4Velocity;
uniform vec2 g_vec2Dimension;
uniform vec3 g_vec3CenterCoord;
uniform vec3 g_vec3ViewCoord;
uniform vec3 g_vec3LightCoord;
uniform mat4 g_mat4ViewProj;
uniform mat4 g_mat4ProjTexture;
    
in vec2 g_vec2TexCoord;
in vec2 g_vec2VertexCoord;

out vec2 g_vec2ProjTexCoord;
out vec4 g_vec4NormalTexCoord;
out vec3 g_vec3WorldViewDirection;
out vec3 g_vec3TangentViewDirection;
out vec3 g_vec3TangentLightDirection;

// @desc: Tangent space matrix.
const mat3 g_mat3Tangent = mat3(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f);                                

// @desc: The entry of vertex shader.
void main()
{
    // Calculate view direction and light direction in tangnent space.
    vec4 vec4VertexCoord = vec4(g_vec2VertexCoord.x*g_vec2Dimension.x + g_vec3CenterCoord.x, 
                                g_vec3CenterCoord.y, 
                                g_vec2VertexCoord.y*g_vec2Dimension.y + g_vec3CenterCoord.z, 1.0f);
    g_vec3WorldViewDirection = g_vec3ViewCoord - vec4VertexCoord.xyz;
    g_vec3TangentViewDirection = g_vec3WorldViewDirection*g_mat3Tangent;
    g_vec3TangentLightDirection = (g_vec3LightCoord - vec4VertexCoord.xyz)*g_mat3Tangent;

    // Calculate projected texture coordinate and normal texture coordinate.
    vec4 vec4ProjTexCoord = g_mat4ProjTexture*vec4VertexCoord;
    g_vec2ProjTexCoord = vec4ProjTexCoord.xy/vec4ProjTexCoord.w;
    g_vec4NormalTexCoord = vec4(g_vec2TexCoord + g_vec4Velocity.xy, g_vec2TexCoord + g_vec4Velocity.zw);
    
    // Calculate the coordinate of vertex in clipping space.
    gl_Position = g_mat4ViewProj*vec4VertexCoord;
}

#version 130
uniform vec3 g_vec3LightDirection;
uniform vec3 g_vec3Irradiance;
uniform vec3 g_vec3Diffuse;
uniform vec3 g_vec3Specular;
uniform float g_fSmoothness;
uniform float g_fPerturbation;
uniform vec2 g_vec2FrenelPara;
uniform sampler2D g_ReflectMap;
uniform sampler2D g_RefracMap;
uniform sampler2D g_LowFrequencyNormalMap;
uniform sampler2D g_HighFrequencyNormalMap;

in vec2 g_vec2ProjTexCoord;
in vec4 g_vec4NormalTexCoord;
in vec3 g_vec3WorldViewDirection;
in vec3 g_vec3TangentViewDirection;
in vec3 g_vec3TangentLightDirection;

out vec4 g_vec4FragColor;

// @desc: The original surface normal.
const vec3 g_vec3OriginNormal = vec3(0.0f, 1.0f, 0.0f);

// @desc: The entry of fragment shader.
void main()
{
    // Calculate synthetical normal.
    vec3 vec3LowFrequencyNormal = (texture2D(g_LowFrequencyNormalMap, g_vec4NormalTexCoord.xy).xyz - 0.5f)*2.0f;
    vec3 vec3HighFrequencyNormal = (texture2D(g_HighFrequencyNormalMap, g_vec4NormalTexCoord.zw).xyz - 0.5f)*2.0f;
    vec3 vec3SynthNormal = normalize(vec3LowFrequencyNormal + vec3HighFrequencyNormal);
    
    // Calculate diffuse gene.
    vec3 vec3TangentLightDirection = normalize(g_vec3TangentLightDirection);
    float fDiffuseGene = max(dot(vec3SynthNormal, vec3TangentLightDirection), 0.0f);

    // Calculate specular gene.
    float fSpecularGene = 0.0f;
    if (fDiffuseGene > 0.0f)
    {
        vec3 vec3TangentViewDirection = normalize(g_vec3TangentViewDirection);
        vec3 vec3Reflection = reflect(-vec3TangentViewDirection, vec3SynthNormal);
        fSpecularGene = pow(max(dot(vec3Reflection, vec3TangentLightDirection), 0.0f), g_fSmoothness);
    }
    
    // Fectch the sample of reflect texture and refract texture.
    vec2 vec2DistortProjTexCoord = g_vec2ProjTexCoord + g_fPerturbation*vec3SynthNormal.xy;
    vec3 vec3Reflect = texture2D(g_ReflectMap, vec2DistortProjTexCoord).xyz;
    vec3 vec3Refract = texture2D(g_RefracMap, vec2DistortProjTexCoord).xyz;
    
    // Calculate fresnel law.
    vec3 vec3WorldViewDirection = normalize(g_vec3WorldViewDirection);
    float fFresnelGene = g_vec2FrenelPara.x + g_vec2FrenelPara.y*pow(1.0f - dot(vec3WorldViewDirection, g_vec3OriginNormal), 5.0f);
    vec3 vec3Fresnel = mix(vec3Refract, vec3Reflect, fFresnelGene);
    
    // Calculate the exitance of light.
    vec3 vec3Exitance = (fDiffuseGene*g_vec3Diffuse*vec3Fresnel + fSpecularGene*g_vec3Specular)*g_vec3Irradiance;
    g_vec4FragColor = vec4(vec3Exitance, 1.0f);
}