/*********************************************************************NVMH3****
Copyright NVIDIA Corporation 2003
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
	Simple ocean shader with animated bump map and geometric waves
	Based partly on "Effective Water Simulation From Physical Models", GPU Gems

11 Aug 05: converted from HLSL to GLSL by Jeff Doyle (nfz) to work in Ogre
15 Jun 25: converted to OgreUnifiedShader.h by Sergey Lapin

******************************************************************************/

OGRE_NATIVE_GLSL_VERSION_DIRECTIVE
#include <OgreUnifiedShader.h>

SAMPLER2D(noiseMap, 0);
SAMPLER2D(reflectMap, 1);
SAMPLER2D(refractMap, 2);

OGRE_UNIFORMS(
    uniform vec4 ambient;
    uniform vec4 diffuse;
    uniform highp float time;
    uniform vec4 deepColor;
    uniform vec4 shallowColor;
    uniform vec4 reflectionColor;
    uniform float reflectionAmount;
    uniform float reflectionBlur;
    uniform float waterAmount;
    uniform vec4 tintColour;
    uniform float noiseScale;
    uniform float fresnelScale;
    uniform float fresnelPower;
    uniform float fresnelBias;
    uniform float hdrMultiplier;
)
MAIN_PARAMETERS
IN(mat3 rotMatrix, 17) // first row of the 3x3 transform from tangent to cube space
IN(vec2 bumpCoord0, 18)
IN(vec2 bumpCoord1, 19)
IN(vec2 bumpCoord2, 20)
IN(vec3 eyeVector, 21)
IN(vec3 noiseCoord, 22)
IN(highp vec4 projectionCoord, 23)
IN(vec3 eyeDir, 24)
IN(vec3 oNormal, 25)
MAIN_DECLARATION
{
//	vec4 t0 = texture2D(NormalMap, bumpCoord0) * 2.0 - 1.0;
//	vec4 t1 = texture2D(NormalMap, bumpCoord1) * 2.0 - 1.0;
//	vec4 t2 = texture2D(NormalMap, bumpCoord2) * 2.0 - 1.0;
	vec4 t0 = normalize(vec4(0.1, 1, 0, 1));
	vec4 t1 = normalize(vec4(0, 1, 0.1, 1));
	vec4 t2 = normalize(vec4(-0.1, 1, 0.1, 1));
	// Do the tex projection manually so we can distort _after_
	vec2 final = projectionCoord.xy / projectionCoord.w;

	// Noise
	vec3 noiseNormal = (texture2D(noiseMap, (noiseCoord.xy / 5.0)).rgb - 0.5).rbg * noiseScale;
	final += noiseNormal.xz;
	
//	final.x = clamp(1.0 + final.x - floor(1.0 + final.x), 0.0, 1.0);
//	float m = 0.2;
//	final.y = final.y * (1.0 - m) + m * 0.5;
//	final.y = clamp(1.0 + final.y - floor(1.0 + final.y), 0.0, 1.0);

	vec3 N = t0.xyz + t1.xyz + t2.xyz;
	N = normalize(rotMatrix * N);
	vec3 E = normalize(eyeVector);
	vec3 R = reflect(E, N);
	R.z = -R.z;
	// vec4 reflection = vec4(0.4, 0.4, 0.8, 1.0);
	// vec4 reflection = textureCube(EnvironmentMap, R, reflectionBlur);
	// Reflection / refraction
	
	vec4 reflectionColour = texture2D(reflectMap, final);
	vec4 refractionColour = texture2D(refractMap, final) + tintColour;
	reflectionColour.rgb *= (reflectionColour.r + reflectionColour.g + reflectionColour.b) * hdrMultiplier;
	float facing = 1.0 - dot(-E, N);

	// float fresnel = clamp(fresnelBias + pow(facing, fresnelPower), 0.0, 1.0);
	float fresnel = clamp(fresnelBias + fresnelScale * pow(1.0 + dot(eyeDir, oNormal), fresnelPower), 0.0, 1.0);
	vec4 waterColor = mix(shallowColor, deepColor, facing) * waterAmount;
	vec4 reflection = mix(waterColor,  reflectionColour, fresnel) * reflectionAmount;
	// reflection = mix(waterColor,  reflection * reflectionColor, fresnel) * reflectionAmount;
	// gl_FragColor = mix(waterColor, reflectionColour, reflectionAmount);
	vec4 r = mix(refractionColour, reflectionColour, fresnel) * reflectionAmount;
	gl_FragColor = waterColor + r;
	//gl_FragColor = waterColor + mix(refractionColour, reflection, fresnel);
	//gl_FragColor = refractionColour;
	//gl_FragColor = reflectionColour;
	//gl_FragColor = ambient * diffuse;
}