/*********************************************************************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: modified to work with OgreUnifiedShader.h

******************************************************************************/
OGRE_NATIVE_GLSL_VERSION_DIRECTIVE
#include <OgreUnifiedShader.h>
#line 3

OGRE_UNIFORMS(
uniform vec3 eyePosition;
uniform float BumpScale;
uniform vec2 textureScale;
uniform vec2 bumpSpeed;
uniform highp float time;
uniform float waveFreq;
uniform float waveAmp;
uniform mat4 world;
uniform mat4 worldViewProj;
uniform mat4 textureProjMatrix;
uniform mat3 normalMatrix;
uniform float scale;  // the amount to scale the noise texture by
uniform float scroll; // the amount by which to scroll the noise
uniform float noise;  // the noise perturb as a factor of the time
)
// wave functions
struct Wave {
  float freq;  // 2*PI / wavelength
  float amp;   // amplitude
  float phase; // speed * 2*PI / wavelength
  vec2 dir;
};

MAIN_PARAMETERS
IN(vec4 vertex, POSITION)
IN(vec3 normal, NORMAL)
// IN(vec3 tangent, TANGENT)
IN(vec3 uv0, TEXCOORD0)
OUT(mat3 rotMatrix, TEXCOORD1)
//OUT(vec4 bumpCoordA, TEXCOORD2)
//OUT(vec4 bumpCoordB, TEXCOORD3)
// OUT(vec3 noiseCoord, TEXCOORD4)
OUT(highp vec4 projectionCoord, TEXCOORD4)
//OUT(vec3 eyeDir, TEXCOORD5)
//OUT(vec3 oNormal, TEXCOORD6)
OUT(f32vec3 positionWS, TEXCOORD7)
MAIN_DECLARATION
{
#if 1
#define NWAVES 4
	Wave wave[NWAVES];
	wave[0] = Wave( waveFreq, waveAmp, 0.5, vec2(-1.0, 0.0) );
	wave[1] = Wave( 3.0 * waveFreq, 0.33 * waveAmp, 1.7, vec2(-0.7, 0.7) );
	wave[2] = Wave( 7.5 * waveFreq, 0.15 * waveAmp, 2.9, vec2(-0.2, 0.2) );
	wave[3] = Wave( 11.5 * waveFreq, 0.075 * waveAmp, 5.9, vec2(-0.2, 0.3) );
	vec4 P = worldViewProj * vertex;
	vec4 R = vertex;
	// sum waves
	float ddx = 0.0, ddy = 0.0;
	float deriv;
	float angle;
	projectionCoord = mul(textureProjMatrix, vertex);

	// Noise map coords
//	noiseCoord.xy = (uv0.xy + (time * scroll)) * scale;
//	noiseCoord.z = noise * time;
	// wave synthesis using two sine waves at different frequencies and phase shift
	for(int i = 0; i<NWAVES; ++i)
	{
		angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
		P.y += wave[i].amp * sin( angle );
		// calculate derivate of wave function
		deriv = wave[i].freq * wave[i].amp * cos(angle);
		ddx -= deriv * wave[i].dir.x;
		ddy -= deriv * wave[i].dir.y;
	}
	R.y = P.y;
	// compute the 3x3 transform from tangent space to object space
	// compute tangent basis
	vec3 T = normalize(vec3(1.0, ddy, 0.0)) * BumpScale;
	vec3 B = normalize(vec3(0.0, ddx, 1.0)) * BumpScale;
	vec3 N = normalize(vec3(ddx, 1.0, ddy));
	rotMatrix = mat3(T, B, N);
	gl_Position = P;
	// calculate texture coordinates for normal map lookup
#if 0
	bumpCoordA.xy = uv0.xy * textureScale + time * bumpSpeed;
	bumpCoordA.zw = uv0.xy * textureScale * 2.0 + time * bumpSpeed * 4.0;
	bumpCoordB.xy = uv0.xy * textureScale * 4.0 + time * bumpSpeed * 8.0;
#endif

	// eyeDir = normalize(R.xyz - eyePosition); 
	// oNormal = normalize(normal + N);
	positionWS = mul(world, vertex).xyz;
#else
	gl_Position = worldViewProj * vertex;
	projectionCoord = mul(textureProjMatrix, vertex);
#endif
}