#version 450

#include "compiled.inc"
#include "std/gbuffer.glsl"
#include "std/math.glsl"

uniform sampler2D gbufferD;
uniform sampler2D tex;
uniform sampler2D sbase;
uniform sampler2D sdetail;
uniform sampler2D sfoam;

#ifdef _SSR
uniform mat4 P;
uniform mat3 V3;
#ifdef _CPostprocess
uniform vec3 PPComp9;
uniform vec3 PPComp10;
#endif
#endif

#ifdef _Rad
uniform sampler2D senvmapRadiance;
#endif

uniform float time;
uniform vec3 eye;
uniform vec3 eyeLook;
uniform vec2 cameraProj;
uniform vec3 ld;
uniform float envmapStrength;

in vec2 texCoord;
in vec3 viewRay;
out vec4 fragColor;

#ifdef _SSR
vec3 hitCoord;
float depth;

const int numBinarySearchSteps = 7;
const int maxSteps = int(ceil(1.0 / ssrRayStep) * ssrSearchDist);

vec2 getProjectedCoord(const vec3 hit) {
	vec4 projectedCoord = P * vec4(hit, 1.0);
	projectedCoord.xy /= projectedCoord.w;
	projectedCoord.xy = projectedCoord.xy * 0.5 + 0.5;
	#ifdef _InvY
	projectedCoord.y = 1.0 - projectedCoord.y;
	#endif
	return projectedCoord.xy;
}

float getDeltaDepth(const vec3 hit) {
	depth = textureLod(gbufferD, getProjectedCoord(hit), 0.0).r * 2.0 - 1.0;
	vec3 viewPos = getPosView(viewRay, depth, cameraProj);
	return viewPos.z - hit.z;
}

vec4 binarySearch(vec3 dir) {
	float ddepth;
	for (int i = 0; i < numBinarySearchSteps; i++) {
		dir *= 0.5;
		hitCoord -= dir;
		ddepth = getDeltaDepth(hitCoord);
		if (ddepth < 0.0) hitCoord += dir;
	}
	// Ugly discard of hits too far away
	#ifdef _CPostprocess
		if (abs(ddepth) > PPComp9.z / 500) return vec4(0.0);
	#else
		if (abs(ddepth) > ssrSearchDist / 500) return vec4(0.0);
	#endif
	return vec4(getProjectedCoord(hitCoord), 0.0, 1.0);
}

vec4 rayCast(vec3 dir) {
	#ifdef _CPostprocess
		dir *= PPComp9.x;
	#else
		dir *= ssrRayStep;
	#endif
	for (int i = 0; i < maxSteps; i++) {
		hitCoord += dir;
		if (getDeltaDepth(hitCoord) > 0.0) return binarySearch(dir);
	}
	return vec4(0.0);
}
#endif //SSR

vec3 sampleWaterNormals(vec2 hitXY, float speed, out vec2 tcnor0, out vec2 tcnor1) {
	tcnor0 = hitXY / 3.0;
	vec3 n0 = textureLod(sdetail, tcnor0 + vec2(speed / 60.0, speed / 120.0), 0.0).rgb;
	tcnor1 = hitXY / 6.0 + n0.xy / 20.0;
	vec3 n1 = textureLod(sbase, tcnor1 + vec2(speed / 40.0, speed / 80.0), 0.0).rgb;
	return normalize(n0 + n1 - 1.0);
}

float waveHeight(vec2 xy, float speed) {
	return (sin(xy.x * 10.0 / waterDisplace + speed) * cos(xy.y * 10.0 / waterDisplace + speed) + sin(xy.x * 20.0 / waterDisplace + speed * 1.3) * cos(xy.y * 20.0 / waterDisplace + speed * 1.3) * 0.5) / 50.0 * waterDisplace;
}

void main() {
	float gdepth = textureLod(gbufferD, texCoord, 0.0).r * 2.0 - 1.0;
	vec3 vray = normalize(viewRay);
	float speed = time * 2.0 * waterSpeed;
	float farPlane = cameraProj.y / (1.0 - cameraProj.x);
	float cosAng = dot(eyeLook, vray);
	float domeR = farPlane * 0.94;
	float tDome = -3.5 * vray.z + sqrt(max(domeR * domeR - 12.25 * (1.0 - vray.z * vray.z), 0.0));
	float domeDepth01 = cameraProj.x + cameraProj.y / (tDome * cosAng);
	bool isSky = (gdepth * 0.5 + 0.5) >= domeDepth01;

	// Ray-plane intersection with water surface (z = waterLevel)
	float denom = vray.z;
	float tWater = (waterLevel - eye.z) / denom;
	bool hasWaterHit = (abs(denom) > 0.0001) && (tWater > 0.0);

	if (eye.z < waterLevel) {
		vec2 tc = texCoord;
		float depthThick = 1.0 + (waterLevel - eye.z);
		vec3 p = vec3(0.0);
		float geomDist = farPlane;
		if (!isSky) {
			p = getPos(eye, eyeLook, vray, gdepth, cameraProj);
			geomDist = length(p - eye);
		}
		bool upRay = hasWaterHit && denom > 0.0;
		float waterDist = upRay ? min(tWater, geomDist) : geomDist;

		vec2 wxy;
		if (upRay && tWater < geomDist) {
			wxy = (eye + tWater * vray).xy;
		} else if (!isSky) {
			wxy = p.xy;
		} else {
			wxy = eye.xy + vray.xy * 50.0;
		}
		vec2 tc0, tc1;
		vec3 n2 = sampleWaterNormals(wxy * waterFreq, speed, tc0, tc1);
		tc = texCoord + (n2.xy * n2.z) / 30.0 * waterRefract;
		float ddepth2 = textureLod(gbufferD, tc, 0.0).r * 2.0 - 1.0;
		float dist2 = cameraProj.y / ((ddepth2 * 0.5 + 0.5) - cameraProj.x) / cosAng;
		if (dist2 > geomDist + 1.0) tc = texCoord;

		vec3 refracted = textureLod(tex, tc, 0.0).rgb;
		vec3 outCol = refracted;

		if (upRay && tWater < geomDist) {
			outCol *= max(1.0 - length(n2.xy) * 1.5, 0.0);
			vec3 h2 = normalize(-vray + ld);
			outCol += pow(max(dot(n2, h2), 0.0), 80.0) * 0.6;
		}

		if (!isSky) {
			float fdw = abs(p.z - (waterLevel + waveHeight(p.xy, speed)));
			float bandw = 0.1 + waterDist * 0.003;
			if (fdw < bandw) {
				float foamLod = clamp(waterDist / 15.0, 0.0, 5.0);
				vec3 fm0 = textureLod(sfoam, tc0 * 3.0 + vec2(speed / 30.0, speed / 50.0), foamLod).rgb;
				vec3 fm1 = textureLod(sfoam, tc1 * 4.0 + vec2(-speed / 35.0, speed / 45.0), foamLod).rgb;
				float fstr = clamp(1.0 - fm0.r * 0.5 - fm1.b * 0.5, 0.0, 1.0);
				float ffac = clamp(1.0 - fdw / bandw, 0.0, 1.0);
				float foamFade = clamp(1.0 - (waterLevel - eye.z) * 0.4, 0.0, 1.0);
				vec3 foamCol = mix(waterColor, vec3(1.0), 0.6);
				outCol = mix(outCol, foamCol, ffac * fstr * 0.5 * foamFade);
			}
		}

		float fogFactor = 1.0 - exp(-waterDist * waterDensity * 0.006 * depthThick);
		outCol = mix(outCol, waterColor, clamp(fogFactor, 0.0, 1.0));

		fragColor.rgb = outCol;
		fragColor.a = 1.0;
		return;
	}

	// Above water
	if (!hasWaterHit || denom >= 0.0) {
		fragColor = vec4(0.0);
		return;
	}

	if (isSky) tWater = min(tWater, 100.0); // Clamp to prevent aliasing at horizon
	vec3 p = isSky ? (eye + tWater * vray) : getPos(eye, eyeLook, vray, gdepth, cameraProj);

	if (!isSky && p.z > waterLevel - 0.01) {
		fragColor = textureLod(tex, texCoord, 0.0);
		return;
	}
	float horizonFactor = clamp(1.0 - tWater / 60.0, 0.0, 1.0);

	// Displace surface
	float geomZ = p.z; // undisplaced depth for foam/fog tests
	p.z += waveHeight(p.xy, speed);

	// Hit plane to determine uvs
	vec3 v = normalize(eye - p);
	float t = (waterLevel - eye.z) / v.z;
	vec3 hit = eye + t * v;

	// Sample normal maps
	vec2 tcnor0, tcnor1;
	vec3 n2 = sampleWaterNormals(hit.xy * waterFreq, speed, tcnor0, tcnor1);

	// Refraction
	vec2 tc;
	if (isSky) {
		tc = texCoord + (n2.xy * n2.z) / 30.0 * waterRefract;
	} else {
		float ddepth = textureLod(gbufferD, texCoord + (n2.xy * n2.z) / 40.0, 0.0).r * 2.0 - 1.0;
		float dist2 = cameraProj.y / ((ddepth * 0.5 + 0.5) - cameraProj.x) / cosAng;
		tc = (eye.z + vray.z * dist2) > waterLevel ? texCoord : texCoord + (n2.xy * n2.z) / 30.0 * waterRefract;
	}

	// Light
	float fresnel = 1.0 - max(dot(n2, v), 0.0);
	fresnel = 0.02 + 0.98 * pow(fresnel, 5.0);
	vec3 r = reflect(-v, n2);
	#ifdef _Rad
	vec3 reflectedEnv = textureLod(senvmapRadiance, envMapEquirect(r), 0).rgb;
	#else
	const vec3 reflectedEnv = vec3(0.5);
	#endif
	vec3 refracted = textureLod(tex, tc, 0.0).rgb;

	#ifdef _SSR
	float roughness = 0.1;//unpackFloat(g0.b).y;
	//if (roughness == 1.0) { fragColor.rgb = vec3(0.0); return; }

	float spec = 0.9;//fract(textureLod(gbuffer1, texCoord, 0.0).a);
	//if (spec == 0.0) { fragColor.rgb = vec3(0.0); return; }

	vec3 viewNormal = V3 * n2;
	vec3 viewPos = isSky ? vec3(0.0) : getPosView(viewRay, gdepth, cameraProj);
	vec3 reflected = reflect(normalize(viewPos), viewNormal);
	hitCoord = viewPos;

	#ifdef _CPostprocess
		vec3 dir = reflected * (1.0 - rand(texCoord) * PPComp10.y * roughness) * 2.0;
	#else
		vec3 dir = reflected * (1.0 - rand(texCoord) * ssrJitter * roughness) * 2.0;
	#endif

	vec4 coords = rayCast(dir);

	vec2 deltaCoords = abs(vec2(0.5, 0.5) - coords.xy);
	float screenEdgeFactor = clamp(1.0 - (deltaCoords.x + deltaCoords.y), 0.0, 1.0);

	float reflectivity = 1.0 - roughness;
	#ifdef _CPostprocess
	float intensity = pow(reflectivity, PPComp10.x) * screenEdgeFactor * clamp(-reflected.z, 0.0, 1.0) * clamp((PPComp9.z - length(viewPos - hitCoord)) * (1.0 / PPComp9.z), 0.0, 1.0) * coords.w;
	#else
	float intensity = pow(reflectivity, ssrFalloffExp)*screenEdgeFactor*clamp(-reflected.z, 0.0, 1.0)*clamp((ssrSearchDist - length(viewPos - hitCoord))*(1.0 / ssrSearchDist), 0.0, 1.0)*coords.w;
	#endif
	intensity = clamp(intensity, 0.0, 1.0);
	vec3 reflCol = textureLod(tex, coords.xy, 0.0).rgb;
	fragColor.rgb = mix(refracted, reflCol * intensity * 0.5, waterReflect * fresnel * 0.5);
	fragColor.rgb = mix(fragColor.rgb, reflectedEnv, waterReflect * fresnel);
	#else
	fragColor.rgb = mix(refracted, reflectedEnv, waterReflect * fresnel);
	#endif
	float colorMix = isSky ? 0.7 : 0.5;
	fragColor.rgb = mix(fragColor.rgb, waterColor, colorMix);
	// Blinn-Phong specular using half-vector, faded at horizon
	vec3 h = normalize(v + ld);
	float specAmount = pow(max(dot(n2, h), 0.0), 200.0) * (200.0 + 8.0) / (PI * 8.0);
	fragColor.rgb += specAmount * (isSky ? 0.3 : 1.0) * horizonFactor;
	float waterColumn = isSky ? 1.0 : max(length(p - eye) - tWater, 0.0);
	float depthFog = 1.0 - exp(-waterColumn * waterDensity * 0.006);
	vec3 surfaceCol = mix(waterColor, reflectedEnv, waterReflect * fresnel);
	fragColor.rgb = mix(fragColor.rgb, surfaceCol, min(depthFog, 0.9));
	// Alpha fades smoothly at horizon instead of hard cut
	// Skydome sits 3.5 below the camera (_skydomeMatrix), so its horizon
	// appears where the ray z reaches -3.5 / domeRadius
	float horizonFade = clamp((-3.5 / (farPlane * 0.95) - vray.z) * 20.0, 0.0, 1.0);
	fragColor.a = isSky ? horizonFade : clamp(abs(geomZ - waterLevel) * 5.0 + 0.1, 0.0, 1.0);
	float waveH = p.z - geomZ; // displacement already applied above
	float band = 0.1 + tWater * 0.003;
	float fd = isSky ? 1.0 : abs(geomZ - (waterLevel + waveH));
	if (fd < band) {
		// Based on foam by Owen Deery
		// http://fire-face.com/personal/water
		// Distance-based LOD blurs foam at range to reduce noise
		float foamLod = clamp(tWater / 15.0, 0.0, 5.0);
		vec2 foamUV0 = tcnor0 * 3.0 + vec2(speed / 30.0, speed / 50.0);
		vec2 foamUV1 = tcnor1 * 4.0 + vec2(-speed / 35.0, speed / 45.0);
		vec3 foamMask0 = textureLod(sfoam, foamUV0, foamLod).rgb;
		vec3 foamMask1 = textureLod(sfoam, foamUV1, foamLod).rgb;
		float foamMask = clamp(1.0 - foamMask0.r * 0.5 - foamMask1.b * 0.5, 0.0, 1.0);
		float fac = clamp(1.0 - fd / band, 0.0, 1.0);
		vec3 foamCol = mix(waterColor, vec3(1.0), 0.6);
		fragColor.rgb = mix(fragColor.rgb, foamCol, fac * foamMask * 0.8);
		fragColor.a = max(fragColor.a, fac * foamMask);
	}
}