TGE water upgrade

struct appdata {
	float4 Position		: POSITION;
	float4 UV0		: TEXCOORD0;
	float4 UV1	    	: TEXCOORD1;
	float4 UV2	    	: TEXCOORD2;
	float4 Normal		: NORMAL;
};

struct vertexOutput {
	float4 HPosition		: POSITION;
	float4 TexCoord0		: TEXCOORD0;	
	float4 TexCoord1		: TEXCOORD1;
	float4 Position			: TEXCOORD2;
	float4 DepthCoord		: TEXCOORD3;	
	float3 EyeVec			: TEXCOORD4;	
	float4 PositionAndFog	: TEXCOORD5;
};

vertexOutput main(appdata IN,
    uniform float4x4 ModelViewProj,
    uniform float4x4 ModelViewIT,
    uniform float4x4 ModelView,
	uniform float2	BaseDrift,
	uniform float	SurfaceParallax,
	uniform float3	EyePos,
	uniform float	FogStart,
	uniform float	FogEnd
)
{
	vertexOutput OUT;
	    
	OUT.TexCoord0 = IN.UV0 + float4(BaseDrift, 0, 0);
	OUT.TexCoord1 = IN.UV0 + float4(BaseDrift*SurfaceParallax, 0, 0);
	OUT.HPosition = mul(ModelViewProj, IN.Position);
	OUT.Position = mul(ModelViewProj, IN.Position);	
	OUT.DepthCoord = IN.UV2;
	
	OUT.EyeVec = EyePos;
	OUT.PositionAndFog.xyz = IN.Position.xyz;
	
	float3 pos = mul(ModelView, IN.Position).xyz;
	float fogDist = length(pos);
	float fogFactor = (FogEnd - fogDist)/(FogEnd - FogStart);

	OUT.PositionAndFog.w = fogFactor;	
		
    return OUT;
}

struct vertexOutput {
    float4 HPosition		: POSITION;
    float4 TexCoord0    	: TEXCOORD0;	
	float4 TexCoord1    	: TEXCOORD1;
    float4 Position     	: TEXCOORD2;
	float4 DepthCoord   	: TEXCOORD3;	
	float3 EyeVec       	: TEXCOORD4;	
	float4 PositionAndFog 	: TEXCOORD5;
};

float fresnel(float NdotV, float bias, float power)
{
   return bias + (1.0-bias)*pow(1.0 - max(NdotV, 0), power);
}

float4 main(vertexOutput IN,
			uniform sampler2D waterTexture : TEXUNIT0,
            uniform sampler2D bumpTexture : TEXUNIT1,
			uniform sampler2D depthTexture : TEXUNIT2,
			uniform float2 TextureRatio,
			uniform float3 waterColor,
			uniform float3 fogColor): COLOR
{

	float2 refCoord = float2( ( IN.Position.x) / (IN.Position.w), 
                               (IN.Position.y) / (IN.Position.w) );
	refCoord = saturate( (refCoord + 1 ) * 0.5 );
	refCoord *= TextureRatio;	
	
	float3 normal0 = tex2D(bumpTexture, IN.TexCoord0.xy).rgb*2.0 - 1.0;
	float3 normal1 = tex2D(bumpTexture, IN.TexCoord1.xy*2).rgb*2.0 - 1.0;
	float3 normal = (normal0 + normal1);
	normal *= 0.1;

	float pix = 1.0/512.0;

	refCoord += normal.xy;
	refCoord.x = min(max(pix, refCoord.x), TextureRatio.x-pix);    
	refCoord.y = min(max(pix, refCoord.y), TextureRatio.y-pix);    
	
	float3 reflected = tex2D(waterTexture, refCoord).rgb;

	float depthAlpha = tex2D(depthTexture, IN.DepthCoord.xy).a;

	//Apply fresnel
	float3 eyeVec = normalize( IN.EyeVec.xyz - IN.PositionAndFog.xyz );
	normal = normalize(normal);
    	float fresnel = dot(eyeVec, normal);
	float bias = 0.12;
	float power = 6.0;
	
	fresnel = bias + (1.0-bias)*pow(1.0 - max(fresnel, 0), power);


	reflected = lerp(waterColor, reflected, fresnel);
	fresnel = max(0, fresnel-0.5)*2;
	
	float4 result = float4(reflected, depthAlpha+fresnel);
	
	float4 tmpresult = float4(result.x, result.y, result.z, 1);
	result.xyz = lerp(fogColor, tmpresult.xyz, clamp(IN.PositionAndFog.w, 0, 1));
	
    return result;
}

class SceneGraph

--SNIP--

public:
   static bool useSpecial;
   bool mReflectPass;
   bool mCameraSubmerged;//CG Water: Hack to change water surface rendering method based on camera being over or under water.

void fluid::Render

//First test made in function!
//CG Water: Hack-of-the-day - to prevent the water surface from being rendered into the reflection texture...
if (gClientSceneGraph->mReflectPass)
	return;

--SNIP--

// Based on the view frustrum, accumulate the list of triangles that
// comprise the fluid surface for this render pass.
RunQuadTree( EyeSubmerged );

//CG Water: Hack to detect if camera is under water or not
gClientSceneGraph->mCameraSubmerged = EyeSubmerged;

CalcVertSpecular();

--SNIP--

// Pass the eye position
cgGLSetParameter3f( cgGetNamedParameter(cgVertexProgram, "EyePos"), m_Eye.X, m_Eye.Y, m_Eye.Z);                
			
// Pass the drift values to the shader
cgGLSetParameter2f( cgGetNamedParameter(cgVertexProgram, "BaseDrift"), BaseDriftX, BaseDriftY);

// Pass the surface parallax to the shader
cgGLSetParameter1f( cgGetNamedParameter(cgVertexProgram, "SurfaceParallax"), m_SurfaceParallax);	

//CG Water: Pass fog start and end distances, as well as fog and water color
//TODO: Add to water and skybox datablocks!
if (EyeSubmerged)
{
	cgGLSetParameter1f( cgGetNamedParameter(cgVertexProgram, "FogStart"), 200.0f);
	cgGLSetParameter1f( cgGetNamedParameter(cgVertexProgram, "FogEnd"), 300.0f);
	cgGLSetParameter3f( cgGetNamedParameter(cgFragProgram, "waterColor"), 0.07f, 0.30f, 0.07f);
	cgGLSetParameter3f( cgGetNamedParameter(cgFragProgram, "fogColor"), 0.82f, 0.828f, 0.844f);	
}
else
{
	cgGLSetParameter1f( cgGetNamedParameter(cgVertexProgram, "FogStart"), 500.0f);
	cgGLSetParameter1f( cgGetNamedParameter(cgVertexProgram, "FogEnd"), 800.0f);
	cgGLSetParameter3f( cgGetNamedParameter(cgFragProgram, "waterColor"), 0.12f, 0.22f, 0.25f);
	cgGLSetParameter3f( cgGetNamedParameter(cgFragProgram, "fogColor"), 0.82f, 0.828f, 0.844f);
}

//CG Water: We don't want to flip culling if we're doing a refraction pass, which is the
//case when we're submerged.
//TODO: Should have a separate state - mRefractionPass!!
pBaseState->mFlipCull = mReflectPass && !mCameraSubmerged; //<--- this was 'pBaseState->mFlipCull = mReflectPass;'

void Sky::render

--SNIP--

if(gClientSceneGraph)
{
	F32 currentVisDis = gClientSceneGraph->getVisibleDistanceMod();
	if(mLastVisDisMod != currentVisDis)
	{
		calcPoints();
		for(S32 i = 0; i < MAX_NUM_LAYERS; ++i)
			mCloudLayer[i].setPoints();

		mLastVisDisMod = currentVisDis;
	}

	//CG Water:  krimzon - PRLD_WATER_SHADER
	if (gClientSceneGraph->mReflectPass)
	{
		glDisable(GL_CLIP_PLANE0);
	}
	// -krimzon
}

--SNIP--

/*
if(depthInFog > 0.0f)
      calcAlphas_Heights(camPos.z, banHeights, alphaBan, depthInFog);
   else // Not in fog so setup default values
   {
      alphaBan[0] = 0.0f;
      alphaBan[1] = 0.0f;
      banHeights[0] = HORIZON;
      banHeights[1] = banHeights[0] + OFFSET_HEIGHT;
   }*/

//CG Water: Added test for reflectpass, since we only want to clip in refraction pass.
   //TODO: I guess this can be done together with the krimzon-fix above.
   // Calculats alpha values and ban heights
   if(depthInFog > 0.0f && gClientSceneGraph && !gClientSceneGraph->mReflectPass)
      calcAlphas_Heights(camPos.z, banHeights, alphaBan, depthInFog);
   else // Not in fog so setup default values
   {
      alphaBan[0] = 0.0f;
      alphaBan[1] = 0.0f;
      banHeights[0] = HORIZON;
      banHeights[1] = banHeights[0] + OFFSET_HEIGHT;
   }

--SNIP--

if(mStormFogOn && mRealFog)
	updateRealFog();

//CG Water:  krimzon - PRLD_WATER_SHADER
if (gClientSceneGraph)
{
	if (gClientSceneGraph->mReflectPass)
		glEnable(GL_CLIP_PLANE0);
}
// -krimzon

PROFILE_END();

bool GameTSCtrl::processCameraQuery

--SNIP--

//CG Water: Only reflect around water plane if we're not submerged - if we're submerged, we'll just
//refract whatever is on the surface.
//FIXME: I guess it would be better to check the pBlock surfaceheight against the gClientSceneGraph
//		cameraposition...?
if (!gClientSceneGraph->mCameraSubmerged) //<--- This line is added so we'll only reflect if we're over water.
	camq->cameraMatrix = getCameraReflection(camq->cameraMatrix, plane);

void TerrainRender::renderBlock

--SNIP--

//CG Water: Use CCW faces as frontfaces when camera is submerged AND we're doing a refraction pass.
//Refraction pass = camera underwater and reflection pass :p
if (gClientSceneGraph->mCameraSubmerged
	&& gClientSceneGraph->mReflectPass)
	glFrontFace(GL_CCW);
else
	glFrontFace(GL_CW); //<-- This was the only line in the file before