#include "common.h"

// Tunables
#define CFG_TEXTURE_TILING 0.2
#define CFG_TEXTURE_DETILING 0.1

#define CFG_SPECULAR 2
#define CFG_GLOSS 900

#define CFG_NORMAL_STRENGTH 0.25

#define CFG_REFRACTION_STRENGTH 0.05

#define CFG_FRESNEL_OFFSET 0.3

#define CFG_SSR_STEPS 8
#define CFG_SSR_START_DISTANCE 1
#define CFG_SSR_STEP_CLAMP 0.2
#define CFG_SSR_DEPTH_CUTOFF 10

// Shader code
struct Appdata
{
	ATTR_INT4 Position	: POSITION;

    ATTR_INT4 Normal	: NORMAL;

    ATTR_INT4 Material0	: TEXCOORD0;
    ATTR_INT4 Material1	: TEXCOORD1;
};

struct VertexOutput
{
    float4 HPosition    : POSITION;

    float4 Weights_Wave: COLOR0;
    float3 Tangents: COLOR1;

    float2 Uv0: TEXCOORD0;
    float2 Uv1: TEXCOORD1;
    float2 Uv2: TEXCOORD2;

    float4 LightPosition_Fog : TEXCOORD3;

	float3 Normal: TEXCOORD4;
    float4 View_Depth: TEXCOORD5;

#ifdef PIN_HQ
	float4 PositionScreen: TEXCOORD6;
#endif
};

WORLD_MATRIX_ARRAY(WorldMatrixArray, 75);

uniform float4 WaveParams; // .x = frequency  .y = phase  .z = height  .w = lerp
uniform float4 WaterColor; // deep water color
uniform float4 WaterParams; // .x = refraction depth scale, .y = refraction depth offset

float3 displacePosition(float3 position, float waveFactor)
{
	float x = sin((position.z - position.x) * WaveParams.x - WaveParams.y);
	float z = sin((position.z + position.x) * WaveParams.x + WaveParams.y);
	float p = (x + z) * WaveParams.z;

	float3 result = position;
	
	result.y += p * waveFactor;

	return result;
}

float4 clipToScreen(float4 pos)
{
#ifdef GLSL
	pos.xy = pos.xy * 0.5 + 0.5 * pos.w;
#else
	pos.xy = pos.xy * float2(0.5, -0.5) + 0.5 * pos.w;
#endif
	return pos;
}

float2 getUV(float3 position, ATTR_INT projection, float seed)
{
	float3 u = WorldMatrixArray[1 + int(projection)].xyz;
	float3 v = WorldMatrixArray[19 + int(projection)].xyz;

    float2 uv = float2(dot(position, u), dot(position, v)) * (0.25 * CFG_TEXTURE_TILING);

    uv += CFG_TEXTURE_DETILING * float2(seed, floor(seed * 2.6651441f));

    return uv;
}

VertexOutput WaterVS(Appdata IN)
{
    VertexOutput OUT = (VertexOutput)0;
    
	float3 posWorld = IN.Position.xyz * WorldMatrixArray[0].w + WorldMatrixArray[0].xyz;
    float3 normalWorld = IN.Normal.xyz * (1.0 / 127.0) - 1.0;

#if defined(GLSLES) && !defined(GL3) // iPad2 workaround
    float3 weights = abs(abs(IN.Position.www) - float3(1, 2, 3)) < 0.1;
#else
    float3 weights = abs(IN.Position.www) == float3(1, 2, 3);
#endif

    float waveFactor = dot(weights, IN.Material0.xyz) * (1.0 / 255.0);

#ifdef PIN_HQ
	float fade = saturate0(1 - dot(posWorld - G(CameraPosition), -G(ViewDir).xyz) * G(FadeDistance_GlowFactor).y);

	posWorld = displacePosition(posWorld, waveFactor * fade);
#endif

	OUT.HPosition = mul(G(ViewProjection), float4(posWorld, 1));
    OUT.HPosition.z += (IN.Position.w < 0) * 0.02;

    OUT.LightPosition_Fog = float4(lgridPrepareSample(lgridOffset(posWorld, normalWorld)), (G(FogParams).z - OUT.HPosition.w) * G(FogParams).w);

    OUT.Uv0 = getUV(posWorld, IN.Material1.x, IN.Normal.w);
    OUT.Uv1 = getUV(posWorld, IN.Material1.y, IN.Material0.w);
    OUT.Uv2 = getUV(posWorld, IN.Material1.z, IN.Material1.w);

    OUT.Weights_Wave.xyz = weights;
    OUT.Weights_Wave.w = waveFactor;

	OUT.Normal = normalWorld;
    OUT.View_Depth = float4(G(CameraPosition) - posWorld, OUT.HPosition.w);
	OUT.Tangents = float3(IN.Material1.xyz) > 7.5; // side vs top

#ifdef PIN_HQ
	OUT.PositionScreen = clipToScreen(OUT.HPosition);
#endif

	return OUT;
}

TEX_DECLARE2D(NormalMap1, 0);
TEX_DECLARE2D(NormalMap2, 1);
TEX_DECLARECUBE(EnvMap, 2);
LGRID_SAMPLER(LightMap, 3);
TEX_DECLARE2D(LightMapLookup, 4);
TEX_DECLARE2D(GBufferColor, 5);
TEX_DECLARE2D(GBufferDepth, 6);

float fresnel(float ndotv)
{
	return saturate(0.78 - 2.5 * abs(ndotv)) + CFG_FRESNEL_OFFSET;
}

float4 sampleMix(float2 uv)
{
#ifdef PIN_HQ
	return lerp(tex2D(NormalMap1, uv), tex2D(NormalMap2, uv), WaveParams.w);
#else
	return tex2D(NormalMap1, uv);
#endif
}

float3 sampleNormal(float2 uv0, float2 uv1, float2 uv2, float3 w, float3 normal, float3 tsel)
{
	return terrainNormal(sampleMix(uv0), sampleMix(uv1), sampleMix(uv2), w, normal, tsel);
}

float3 sampleNormalSimple(float2 uv0, float2 uv1, float2 uv2, float3 w)
{
    float4 data = sampleMix(uv0) * w.x + sampleMix(uv1) * w.y + sampleMix(uv2) * w.z;

    return nmapUnpack(data).xzy;
}

float unpackDepth(float2 uv)
{
	return tex2D(GBufferDepth, uv).r * GBUFFER_MAX_DEPTH;
}

float3 getRefractedColor(float4 cpos, float3 N, float3 waterColor)
{
    float2 refruv0 = cpos.xy / cpos.w;
    float2 refruv1 = refruv0 + N.xz * CFG_REFRACTION_STRENGTH;

    float4 refr0 = tex2D(GBufferColor, refruv0);
	refr0.w = unpackDepth(refruv0);

    float4 refr1 = tex2D(GBufferColor, refruv1);
	refr1.w = unpackDepth(refruv1);

	float4 result = lerp(refr0, refr1, saturate(refr1.w - cpos.w));

	// Estimate water absorption by a scaled depth difference
	float depthfade = saturate((result.w - cpos.w) * WaterParams.x + WaterParams.y);

	// Since GBuffer depth is clamped we tone the refraction down after half of the range for a smooth fadeout
	float gbuffade = saturate(cpos.w * (2.f / GBUFFER_MAX_DEPTH) - 1);

	float fade = saturate(depthfade + gbuffade);

    return lerp(result.rgb, waterColor, fade);
}

float3 getReflectedColor(float4 cpos, float3 wpos, float3 R)
{
    float3 result = 0;
    float inside = 0;

    float distance = CFG_SSR_START_DISTANCE;
    float diff = 0;
	float diffclamp = cpos.w * CFG_SSR_STEP_CLAMP;

	float4 Pproj = cpos;
	float4 Rproj = clipToScreen(mul(G(ViewProjection), float4(R, 0)));

#ifndef GLSL
	[unroll]
#endif
    for (int i = 0; i < CFG_SSR_STEPS; ++i)
    {
        distance += clamp(diff, -diffclamp, diffclamp);

        float4 cposi = Pproj + Rproj * distance;
        float2 uv = cposi.xy / cposi.w;
        float depth = unpackDepth(uv);

        diff = depth - cposi.w;
    }

    float4 cposi = Pproj + Rproj * distance;
    float2 uv = cposi.xy / cposi.w;

	// Ray hit has to be inside the screen bounds (tolerate 5% on left/right to reduce wedge-like artifacts on the sides)
    float ufade = abs(uv.x - 0.5) < 0.55;
    float vfade = abs(uv.y - 0.5) < 0.5;

	// Fade reflections out with distance; use max(ray hit, original depth) to discard hits that are too far
	// 4 - depth * 4 would give us fade out from 0.75 to 1; 3.9 makes sure reflections go to 0 slightly before GBUFFER_MAX_DEPTH
    float wfade = saturate((4 - 0.1) - max(cpos.w, cposi.w) * (4.f / GBUFFER_MAX_DEPTH));

	// Ray hit has to be reasonably close to where we started
    float dfade = abs(diff) < CFG_SSR_DEPTH_CUTOFF;

	// Avoid back-projection 
    float Vfade = Rproj.w > 0;

    float fade = ufade * vfade * wfade * dfade * Vfade;

    return lerp(texCUBE(EnvMap, R).rgb, tex2D(GBufferColor, uv).rgb, fade);
}

float4 WaterPS(VertexOutput IN): COLOR0
{
    float4 light = lgridSample(TEXTURE(LightMap), TEXTURE(LightMapLookup), IN.LightPosition_Fog.xyz);
	float shadow = light.a;

	float3 w = IN.Weights_Wave.xyz;

	// Use simplified normal reconstruction for LQ mobile (assumes flat water surface)
#if defined(GLSLES) && !defined(PIN_HQ)
	float3 normal = sampleNormalSimple(IN.Uv0, IN.Uv1, IN.Uv2, w);
#else
	float3 normal = sampleNormal(IN.Uv0, IN.Uv1, IN.Uv2, w, IN.Normal, IN.Tangents);
#endif

	// Flatten the normal for Fresnel and for reflections to make them less chaotic
	float3 flatNormal = lerp(IN.Normal, normal, CFG_NORMAL_STRENGTH);

	float3 waterColor = WaterColor.rgb;

#ifdef PIN_HQ
	float fade = saturate0(1 - IN.View_Depth.w * G(FadeDistance_GlowFactor).y);

	float3 view = normalize(IN.View_Depth.xyz);

	float fre = fresnel(dot(flatNormal, view)) * IN.Weights_Wave.w;

	float3 position = G(CameraPosition) - IN.View_Depth.xyz;

#ifdef PIN_GBUFFER
    float3 refr = getRefractedColor(IN.PositionScreen, normal, waterColor);
	float3 refl = getReflectedColor(IN.PositionScreen, position, reflect(-view, flatNormal));
#else
    float3 refr = waterColor;
	float3 refl = texCUBE(EnvMap, reflect(-view, flatNormal)).rgb;
#endif

    float specularIntensity = CFG_SPECULAR * fade;
    float specularPower = CFG_GLOSS;

	float3 specular = G(Lamp0Color) * (specularIntensity * shadow * (float)(half)pow(saturate(dot(normal, normalize(-G(Lamp0Dir) + view))), specularPower));
#else
	float3 view = normalize(IN.View_Depth.xyz);

	float fre = fresnel(dot(flatNormal, view));

    float3 refr = waterColor;

	float3 refl = texCUBE(EnvMap, reflect(-IN.View_Depth.xyz, flatNormal)).rgb;

	float3 specular = 0;
#endif

    // Combine
	float4 result;
    result.rgb = lerp(refr, refl, fre) * (G(AmbientColor).rgb + G(Lamp0Color).rgb * shadow + light.rgb) + specular;
    result.a = 1;

    float fogAlpha = saturate(IN.LightPosition_Fog.w);

    result.rgb = lerp(G(FogColor), result.rgb, fogAlpha);

	return result;
}
