#version 330

uniform sampler2D gPos;
uniform sampler2D tex;
uniform sampler2D shadowmap;
uniform vec3 viewPos;
uniform vec3 sun;
uniform vec4 fogColor;
uniform vec2 screenSize;

uniform float alpha; // Alpha of the semi-transparant layer

// Fragment information
in vec4 fragPos;
in vec4 fragPosView;
in vec4 fragPosScreen;
in vec4 fragPosLightspace;
in vec3 fragNormal;
in vec2 fragTexCoord;
vec4 fragColor;

out vec4 outputColor;


const float gamma = 2.2;

const float ambient = 0.3, specularStrength = 1.6, specularShininess = 128;
const float fogDensity = .00003;


float sunalpha = 0;
float light;
vec3 color = vec3(0);
void lightSun();
float lightSunShadow();
void lightPoint(int i);


void main() {

	fragColor = vec4(texture(tex, fragTexCoord).rgb, 1.0f);

	light = ambient;

	lightSun();

	color += fragColor.rgb * light;

	//float z = gl_FragCoord.z / gl_FragCoord.w;
	//float fog = clamp(exp(-fogDensity * z * z), 0.2, 1);

	float waterDepth = (fragPosView.z-texture(gPos, gl_FragCoord.xy/screenSize).a);

	float waterFactor = pow(alpha, waterDepth);
	outputColor = vec4(color*waterFactor, min(1-waterFactor + sunalpha, 1));
}

void lightSun() {
	/* Diffuse */
	vec3 lightDir = sun;
	float diffuse = max(dot(fragNormal, lightDir), 0.0f);

	/* Specular */
	vec3 viewDir = normalize(viewPos - fragPos.xyz);
	vec3 reflectDir = reflect(-lightDir, fragNormal);
	float specular = specularStrength * pow(max(dot(viewDir, reflectDir), 0.0), specularShininess);

	float shadow = lightSunShadow();
	light += diffuse * shadow;
	color += vec3(specular) * shadow;

	if (specular*shadow > 1.0f)
		sunalpha += specular*shadow - 1.0f;
	sunalpha += 0.1f*shadow;
}

float lightSunShadow() {
	/* Shadow */
	float bias = max(0.0013 * (1.0 - dot(fragNormal, sun)), 0.0001);
	vec3 projCoords = fragPosLightspace.xyz / fragPosLightspace.w;
	projCoords = projCoords*0.5 + 0.5;
	float closestDepth = texture(shadowmap, projCoords.xy).r;
	float currentDepth = projCoords.z;
	float shadow = 0;

	if (currentDepth > 1.0f || currentDepth < 0.0f)
		return 1.0f;

	//vec2 texelSize = clamp((currentDepth+bias-closestDepth)*100.0f, 0.05f, 1.5f) / textureSize(shadowmap, 0);
	vec2 texelSize = 0.4 / textureSize(shadowmap, 0);
	for (int x=-4; x<=4; ++x)
		for (int y=-4; y<=4; ++y) {
			float pcfDepth = texture(shadowmap, projCoords.xy + vec2(x,y)*texelSize).r;
			shadow += currentDepth-bias < pcfDepth ? 1.0f : 0.0f;
		}
	return min(shadow/81.0f, 1.0f);
}