12 files changed, 2422 insertions, 599 deletions

diff --git a/src/core/Game.cpp b/src/core/Game.cpp
index 72b09feb..9a1c00a7 100644
--- a/src/core/Game.cpp
+++ b/src/core/Game.cpp
@@ -306,7 +306,7 @@ bool CGame::Initialise(const char* datFile)
 	CWorld::Players[0].LoadPlayerSkin();
 	TestModelIndices();
 	LoadingScreen("Loading the Game", "Setup water", nil);
-	CWaterLevel::Initialise("DATA\\WATER.DAT");
+	WaterLevelInitialise("DATA\\WATER.DAT");
 	TheConsole.Init();
 	CDraw::SetFOV(120.0f);
 	CDraw::ms_fLODDistance = 500.0f;
@@ -686,6 +686,13 @@ CGame::InitAfterFocusLoss()
 }
 
 bool
+CGame::CanSeeWaterFromCurrArea(void)
+{
+	return currArea == AREA_MAIN_MAP || currArea == AREA_MANSION
+		|| currArea == AREA_HOTEL;
+}
+
+bool
 CGame::CanSeeOutSideFromCurrArea(void)
 {
 	return currArea == AREA_MAIN_MAP || currArea == AREA_MALL || 
diff --git a/src/core/Game.h b/src/core/Game.h
index 7ad8d55e..49a3e67c 100644
--- a/src/core/Game.h
+++ b/src/core/Game.h
@@ -62,6 +62,7 @@ public:
 	static void InitAfterFocusLoss(void);
 
 	static bool IsInInterior(void) { return currArea != AREA_MAIN_MAP; }
+	static bool CanSeeWaterFromCurrArea(void);
 	static bool CanSeeOutSideFromCurrArea(void);
 	
 	// NB: these do something on PS2
diff --git a/src/core/Pad.cpp b/src/core/Pad.cpp
index 69f340dd..c52c7c36 100644
--- a/src/core/Pad.cpp
+++ b/src/core/Pad.cpp
@@ -35,6 +35,7 @@
 #include "Streaming.h"
 #include "PathFind.h"
 #include "Wanted.h"
+#include "WaterLevel.h"
 #include "General.h"
 
 CPad Pads[MAX_PADS];
@@ -306,6 +307,21 @@ void PinkCarsCheat()
 	gbBlackCars = false;
 	gbPinkCars = true;
 }
+
+void NoSeaBedCheat(void)
+{
+	CHud::SetHelpMessage(TheText.Get("CHEAT1"), true);
+	CWaterLevel::m_bRenderSeaBed = !CWaterLevel::m_bRenderSeaBed;
+}
+
+void RenderWaterLayersCheat(void)
+{
+	CHud::SetHelpMessage(TheText.Get("CHEAT1"), true);
+	if ( ++CWaterLevel::m_nRenderWaterLayers > 5 )
+			CWaterLevel::m_nRenderWaterLayers = 0;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 
 #ifdef KANGAROO_CHEAT
@@ -1051,6 +1067,16 @@ void CPad::AddToPCCheatString(char c)
 	if (!_CHEATCMP("ODODRETSAMOTTNAWI"))
 		AltDodoCheat();
 #endif
+
+#if !defined(PC_WATER) && defined(WATER_CHEATS)
+	// SEABEDCHEAT
+	if (!_CHEATCMP("TAEHCDEBAESON"))
+		NoSeaBedCheat();
+	
+	// WATERLAYERSCHEAT
+	if (!_CHEATCMP("TAEHCSREYALRETAW"))
+		RenderWaterLayersCheat();
+#endif
 	
 	#undef _CHEATCMP
 }
diff --git a/src/core/ZoneCull.h b/src/core/ZoneCull.h
index e76b7a44..aae06ca0 100644
--- a/src/core/ZoneCull.h
+++ b/src/core/ZoneCull.h
@@ -10,6 +10,8 @@ enum eZoneAttribs
 	ATTRZONE_NOTCULLZONE		= 0x20,
 	ATTRZONE_DOINEEDCOLLISION	= 0x40,
 	ATTRZONE_SUBWAYVISIBLE		= 0x80,
+	
+	ATTRZONE_WATERFUDGE		    = 0x400,
 };
 
 struct CAttributeZone
@@ -53,6 +55,7 @@ public:
 	static bool DoINeedToLoadCollision(void) { return (CurrentFlags_Player & ATTRZONE_DOINEEDCOLLISION) != 0; }
 	static bool PlayerNoRain(void) { return (CurrentFlags_Player & ATTRZONE_NORAIN) != 0; }
 	static bool CamNoRain(void) { return (CurrentFlags_Camera & ATTRZONE_NORAIN) != 0; }
+	static bool WaterFudge(void) { return (CurrentFlags_Camera & ATTRZONE_WATERFUDGE) != 0; }
 	static int32 GetWantedLevelDrop(void) { return CurrentWantedLevelDrop_Player; }
 
 	//--MIAMI: TODO
diff --git a/src/core/config.h b/src/core/config.h
index 42a9c5ff..c90d3cbf 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -205,6 +205,9 @@ enum Config {
 #define RELOADABLES			// some debug menu options to reload TXD files
 #endif
 
+#define PC_WATER
+#define WATER_CHEATS
+
 // Particle
 #define PC_PARTICLE
 //#define PS2_ALTERNATIVE_CARSPLASH // unused on PS2
diff --git a/src/core/main.cpp b/src/core/main.cpp
index aefabfc7..d95e7404 100644
--- a/src/core/main.cpp
+++ b/src/core/main.cpp
@@ -821,7 +821,7 @@ RenderScene(void)
 	CRenderer::RenderBoats();
 	CRenderer::RenderFadingInUnderwaterEntities();
 	RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLNONE);
-	// CWaterLevel::RenderTransparentWater();
+	CWaterLevel::RenderTransparentWater();
 	CRenderer::RenderFadingInEntities();
 	RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLNONE);
 	CWeather::RenderRainStreaks();
@@ -1009,6 +1009,9 @@ Idle(void *arg)
 #ifdef TIMEBARS
 		tbStartTimer(0, "CnstrRenderList");
 #endif
+#ifdef PC_WATER
+		CWaterLevel::PreCalcWaterGeometry();
+#endif
 		CRenderer::ConstructRenderList();
 #ifdef TIMEBARS
 		tbEndTimer("CnstrRenderList");
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index becd7c70..5eb82638 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -18000,8 +18000,9 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 
 		PedSetInCarCB(nil, this);
 		bVehExitWillBeInstant = true;
-		if (IsPlayer())
-			CWaterLevel::AllocateBoatWakeArray();
+		// TODO(Miami):
+		//if (IsPlayer())
+		//	CWaterLevel::AllocateBoatWakeArray();
 	} else {
 		if (zDiff > 4.4f) {
 			if (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR)
@@ -18437,8 +18438,10 @@ CPed::SetExitBoat(CVehicle *boat)
 	SetMoveState(PEDMOVE_STILL);
 	m_vecMoveSpeed = boat->m_vecMoveSpeed;
 #endif
+	
+	// TODO(Miami):
 	// Not there in VC.
-	CWaterLevel::FreeBoatWakeArray();
+	//CWaterLevel::FreeBoatWakeArray();
 }
 
 void
diff --git a/src/render/Occlusion.h b/src/render/Occlusion.h
index ac0ede5e..0d3e26e9 100644
--- a/src/render/Occlusion.h
+++ b/src/render/Occlusion.h
@@ -23,4 +23,7 @@ public:
 	static void Init(void);
 	static void AddOne(float x, float y, float z, float width, float length, float height, float angle);
 	static void ProcessBeforeRendering(void);
+	
+	//TODO:
+	static bool IsAABoxOccluded(CVector pos, float, float, float) { return false; }
 };
diff --git a/src/render/WaterLevel.cpp b/src/render/WaterLevel.cpp
index f1ccccb3..e6dbb9c4 100644
--- a/src/render/WaterLevel.cpp
+++ b/src/render/WaterLevel.cpp
@@ -6,6 +6,7 @@
 #include "Weather.h"
 #include "Camera.h"
 #include "Vehicle.h"
+#include "PlayerPed.h"
 #include "Boat.h"
 #include "World.h"
 #include "General.h"
@@ -19,41 +20,99 @@
 #include "CdStream.h"
 #include "Pad.h"
 #include "RenderBuffer.h"
+#include <rwcore.h>
 #include <rpworld.h>
+#include <rpmatfx.h>
+#include "Occlusion.h"
+#include "Replay.h"
 #include "WaterLevel.h"
+#include "SurfaceTable.h"
 
+#define RwIm3DVertexSet_RGBA(vert, rgba) RwIm3DVertexSetRGBA(vert, rgba.red, rgba.green, rgba.blue, rgba.alpha) // (RwRGBAAssign(&(_dst)->color, &_src))
 
 float TEXTURE_ADDU;
 float TEXTURE_ADDV;
 
+float _TEXTURE_MASK_ADDU;
+float _TEXTURE_MASK_ADDV;
+
+float _TEXTURE_WAKE_ADDU;
+float _TEXTURE_WAKE_ADDV;
+
 int32 CWaterLevel::ms_nNoOfWaterLevels;
 float CWaterLevel::ms_aWaterZs[48];
 CRect CWaterLevel::ms_aWaterRects[48];
-uint8 CWaterLevel::aWaterBlockList[WATER_BLOCK_SIZE][WATER_BLOCK_SIZE];
-uint8 CWaterLevel::aWaterFineBlockList[WATER_FINEBLOCK_SIZE][WATER_FINEBLOCK_SIZE];
+uint8 CWaterLevel::aWaterBlockList[WATER_BLOCK_SECTORS][WATER_BLOCK_SECTORS];
+uint8 CWaterLevel::aWaterFineBlockList[WATER_FINEBLOCK_SECTORS][WATER_FINEBLOCK_SECTORS];
 bool CWaterLevel::WavesCalculatedThisFrame;
+
+
+bool CWaterLevel::RequireWavySector;
+bool CWaterLevel::MaskCalculatedThisFrame;
+CVector CWaterLevel::PreCalculatedMaskPosn;
+bool CWaterLevel::m_bRenderSeaBed;
+int32 CWaterLevel::m_nRenderWaterLayers;
+
 RpAtomic *CWaterLevel::ms_pWavyAtomic;
-RpGeometry *CWaterLevel::apGeomArray[8];
-int16 CWaterLevel::nGeomUsed;
+RpAtomic *CWaterLevel::ms_pMaskAtomic;
+
 
 RwTexture *gpWaterTex;
-RwRaster *gpWaterRaster;
+RwTexture *gpWaterEnvTex;
+RwTexture *gpWaterEnvBaseTex;
+RwTexture *gpWaterWakeTex;
 
+RwRaster *gpWaterRaster;
+RwRaster *gpWaterEnvRaster;
+RwRaster *gpWaterEnvBaseRaster;
+RwRaster *gpWaterWakeRaster;
 
-const float fAdd1 = 180.0f;
-const float fAdd2 = 80.0f;
-const float fRedMult = 0.6f;
-const float fGreenMult = 1.0f;
-const float fBlueMult = 1.4f;
+bool _bSeaLife;
+float _fWaterZOffset = 0.5f;
 
+#ifdef PC_WATER
+float fEnvScale               = 0.25f;
+#else
+float fEnvScale               = 0.5f;
+#endif
+float fWave2InvLength         = 0.03f;
+float fWave2NormScale         = 0.5f;
+float fWave2Ampl              = 0.1f;
+uint8 nWaterAlpha             = 192;
+uint8 nWakeAlpha              = 192;
+float fUnder1                 = 4.0;
+float fUnder2                 = 2.5;
+float fUnder3                 = 1.5;
+int nMaskAlpha                = 230;
+float fAdd1                   = 180.0f;
+float fAdd2                   = 80.0;
+float fRedMult                = 0.6f;
+float fGreenMult              = 1.0f;
+float fBlueMult               = 1.4f;
+float fAlphaMult              = 500.0f;
+float fAlphaBase              = 30.0f;
+float fRandomMoveDiv          = 8.0f;
+float fRandomDamp             = 0.99f;
+float fNormMult               = 2.0f;
+float fNormMultB              = 1.0f;
+float fBumpScale              = 1.5;
+float fBumpTexRepeat          = 2.0;
+float fNormalDirectionScalar1 = 2.0f;
+float fNormalDirectionScalar2 = 1.0f;
+bool bTestDoNormals           = true;
+float fSeaBedZ                =  25.0f;
+float aAlphaFade[5]           = { 0.4f, 1.0f, 0.2f, 1.0f, 0.4f};	//CWaterLevel::RenderWakeSegment
+float fFlatWaterBlendRange    = 0.05f;
+float fStartBlendDistanceAdd  = 64.0f;
+float fMinWaterAlphaMult      = -30.0f;
 
 
 void
-CWaterLevel::Initialise(Const char *pWaterDat)
+WaterLevelInitialise(Const char *pWaterDat)
 {
-	ms_nNoOfWaterLevels = 0;
+	CWaterLevel::ms_nNoOfWaterLevels = 0;
 	
-	int32 hFile = -1;
+	int32 hFile;
 	
 	do
 	{
@@ -65,11 +124,11 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 	{
 		if ( hFile >= 0 )
 		{
-			CFileMgr::Read(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
-			CFileMgr::Read(hFile, (char *)ms_aWaterZs,	sizeof(ms_aWaterZs));
-			CFileMgr::Read(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
-			CFileMgr::Read(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
-			CFileMgr::Read(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+			CFileMgr::Read(hFile, (char *)&CWaterLevel::ms_nNoOfWaterLevels, sizeof(CWaterLevel::ms_nNoOfWaterLevels));
+			CFileMgr::Read(hFile, (char *)CWaterLevel::ms_aWaterZs,	sizeof(CWaterLevel::ms_aWaterZs));
+			CFileMgr::Read(hFile, (char *)CWaterLevel::ms_aWaterRects, sizeof(CWaterLevel::ms_aWaterRects));
+			CFileMgr::Read(hFile, (char *)CWaterLevel::aWaterBlockList, sizeof(CWaterLevel::aWaterBlockList));
+			CFileMgr::Read(hFile, (char *)CWaterLevel::aWaterFineBlockList, sizeof(CWaterLevel::aWaterFineBlockList));
 		}
 		
 		CFileMgr::CloseFile(hFile);
@@ -80,14 +139,27 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 	int32 slot = CTxdStore::FindTxdSlot("particle");
 	CTxdStore::SetCurrentTxd(slot);
 	
-	if ( gpWaterTex == NULL )
-		gpWaterTex = RwTextureRead("waterclear256", NULL);
+	if ( gpWaterTex == nil )
+		gpWaterTex = RwTextureRead("waterclear256", nil);
 	gpWaterRaster = RwTextureGetRaster(gpWaterTex);
 	
+	if ( gpWaterEnvTex == nil )
+		gpWaterEnvTex = RwTextureRead("waterreflection2", nil);
+	gpWaterEnvRaster = RwTextureGetRaster(gpWaterEnvTex);
+	
+#ifdef PC_WATER
+	if ( gpWaterEnvBaseTex == nil )
+		gpWaterEnvBaseTex = RwTextureRead("sandywater", nil);
+	gpWaterEnvBaseRaster = RwTextureGetRaster(gpWaterEnvBaseTex);
+#endif
+	
+	if ( gpWaterWakeTex == nil )
+		gpWaterWakeTex = RwTextureRead("waterwake", nil);
+	gpWaterWakeRaster = RwTextureGetRaster(gpWaterWakeTex);
+	
 	CTxdStore::PopCurrentTxd();
 
-	CreateWavyAtomic();
-	FreeBoatWakeArray();
+	CWaterLevel::CreateWavyAtomic();
 	
 	printf("Done Initing waterlevels\n");
 }
@@ -95,92 +167,153 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 void
 CWaterLevel::Shutdown()
 {
-	FreeBoatWakeArray();
 	DestroyWavyAtomic();
 
-	if ( gpWaterTex != NULL )
-	{
-		RwTextureDestroy(gpWaterTex);
-		gpWaterTex = NULL;
-	}
+#define _DELETE_TEXTURE(t) if ( t )	\
+		{ \
+			RwTextureDestroy(t); \
+			t = nil; \
+		}
+
+	_DELETE_TEXTURE(gpWaterTex);
+	_DELETE_TEXTURE(gpWaterEnvTex);
+	_DELETE_TEXTURE(gpWaterEnvBaseTex);
+
+#undef _DELETE_TEXTURE
 }
 
 void
 CWaterLevel::CreateWavyAtomic()
 {
 	RpGeometry *wavyGeometry;
+	RpGeometry *maskGeometry;
 	RpMaterial *wavyMaterial;
-	RpTriangle *wavyTriangles;
+	RpMaterial *maskMaterial;
+	
+	RpTriangle *wavytlist;
+	RpTriangle *masktlist;
+	
 	RpMorphTarget *wavyMorphTarget;
-	RwSphere boundingSphere;	
+	RpMorphTarget *maskMorphTarget;
+	
+	RwSphere boundingSphere;
+	
 	RwV3d *wavyVert;
-
+	RwV3d *wavyNormal;
+	
+	RwV3d *maskVert;
+	RwV3d *maskNormal;
+	
 	RwFrame *wavyFrame;
+	RwFrame *maskFrame;
 	
 	{
-		wavyGeometry = RpGeometryCreate(9*9, 8*8*2, rpGEOMETRYTRISTRIP
+		wavyGeometry = RpGeometryCreate(17*17, 512, rpGEOMETRYTRISTRIP
 													|rpGEOMETRYTEXTURED
 													|rpGEOMETRYPRELIT
+													|rpGEOMETRYNORMALS
 													|rpGEOMETRYMODULATEMATERIALCOLOR);
-													
-		ASSERT(wavyGeometry != NULL);
-	
+#ifdef PC_WATER
+		RpGeometryAddMorphTarget(wavyGeometry);
+#endif
+	}
+
+	{
+		maskGeometry = RpGeometryCreate(33*33, 2048, rpGEOMETRYTRISTRIP
+													|rpGEOMETRYTEXTURED
+													|rpGEOMETRYPRELIT
+													|rpGEOMETRYNORMALS
+													|rpGEOMETRYMODULATEMATERIALCOLOR);
+#ifdef PC_WATER
+		RpGeometryAddMorphTarget(maskGeometry);
+#endif
 	}
 	
 	{
 		wavyMaterial = RpMaterialCreate();
-		
-		ASSERT(wavyMaterial != NULL);
-		ASSERT(gpWaterTex   != NULL);
-		
 		RpMaterialSetTexture(wavyMaterial, gpWaterTex);
+		RwRGBA watercolor = { 255, 255, 255, 192 };
+		RpMaterialSetColor(wavyMaterial, &watercolor);
 	}
 	
 	{
-		wavyTriangles = RpGeometryGetTriangles(wavyGeometry);
-		
-		ASSERT(wavyTriangles != NULL);
-		/*  
-			[B]       [C]
-			 ***********
-			 *       * *
-			 *     *   *
-			 *   *     *
-			 * *       *
-			 ***********
-			[A]       [D]
-		*/
+		maskMaterial = RpMaterialCreate();
+#ifdef PC_WATER
+		RpMaterialSetTexture(maskMaterial, gpWaterEnvBaseTex);
+#else
+		RpMaterialSetTexture(maskMaterial, gpWaterTex);
+#endif
+		RwRGBA watercolor = { 255, 255, 255, 192 };
+		RpMaterialSetColor(maskMaterial, &watercolor);
+	}
+	
+	{
+		wavytlist = RpGeometryGetTriangles(wavyGeometry);
 		
-		for ( int32 i = 0; i < 8; i++ )
+		for ( int32 i = 0; i < 16; i++ )
 		{
-			for ( int32 j = 0; j < 8; j++ )
-			{	
+			for ( int32 j = 0; j < 16; j++ )
+			{
+				const RwUInt16 base = (RwUInt16)((16 + 1)*i+j);
+	
 				RpGeometryTriangleSetVertexIndices(wavyGeometry, 
-						&wavyTriangles[2 * 8*i + 2*j + 0], /*A*/9*i+j+0, /*B*/9*i+j+1,   /*C*/9*i+j+9+1);
-                                                                  
-				RpGeometryTriangleSetVertexIndices(wavyGeometry,  
-						&wavyTriangles[2 * 8*i + 2*j + 1], /*A*/9*i+j+0, /*C*/9*i+j+9+1, /*D*/9*i+j+9  );
+						wavytlist,     (RwInt16)base, (RwInt16)(base+1),    (RwInt16)(base+16+2));
+
+				RpGeometryTriangleSetVertexIndices(wavyGeometry, 
+						(wavytlist+1), (RwInt16)base, (RwInt16)(base+16+2), (RwInt16)(base+16+1));
 	
-				RpGeometryTriangleSetMaterial(wavyGeometry, &wavyTriangles[2 * 8*i + 2*j + 0], wavyMaterial);
-				RpGeometryTriangleSetMaterial(wavyGeometry, &wavyTriangles[2 * 8*i + 2*j + 1], wavyMaterial);
+				RpGeometryTriangleSetMaterial(wavyGeometry, wavytlist,     wavyMaterial);
+
+				RpGeometryTriangleSetMaterial(wavyGeometry, (wavytlist+1), wavyMaterial);
+				
+				wavytlist+=2;
 			}
 		}
 	}
 	
+	{
+		masktlist = RpGeometryGetTriangles(maskGeometry);
+		
+		for ( int32 i = 0; i < 32; i++ )
+		{
+			for ( int32 j = 0; j < 32; j++ )
+			{
+				const RwUInt16 base = (RwUInt16)((32 + 1)*i+j);
+	
+				RpGeometryTriangleSetVertexIndices(maskGeometry, 
+						masktlist,     (RwInt16)base, (RwInt16)(base+1),    (RwInt16)(base+32+2));
+
+				RpGeometryTriangleSetVertexIndices(maskGeometry,
+						(masktlist+1), (RwInt16)base, (RwInt16)(base+32+2), (RwInt16)(base+32+1));
+	
+				RpGeometryTriangleSetMaterial(maskGeometry, masktlist,     maskMaterial);
+
+				RpGeometryTriangleSetMaterial(maskGeometry, (masktlist+1), maskMaterial);
+				
+				masktlist+=2;
+			}
+		}
+	}
 
 	{
 		wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
-		ASSERT(wavyMorphTarget != NULL);
-		wavyVert = RpMorphTargetGetVertices(wavyMorphTarget);	
-		ASSERT(wavyVert != NULL);
+		wavyVert = RpMorphTargetGetVertices(wavyMorphTarget);
+		wavyNormal = RpMorphTargetGetVertexNormals(wavyMorphTarget);
 		
-		for ( int32 i = 0; i < 9; i++ )
+		for ( int32 i = 0; i < 17; i++ )
 		{
-			for ( int32 j = 0; j < 9; j++ )
+			for ( int32 j = 0; j < 17; j++ )
 			{
-				wavyVert[9*i+j].x = (float)i * 4.0f;
-				wavyVert[9*i+j].y = (float)j * 4.0f;
-				wavyVert[9*i+j].z = 0.0f;
+				(*wavyVert).x = (float)i * 2.0f;
+				(*wavyVert).y = (float)j * 2.0f;
+				(*wavyVert).z = 0.0f;
+				
+				(*wavyNormal).x = 0.0f;
+				(*wavyNormal).y = 0.0f;
+				(*wavyNormal).z = 1.0f;
+				
+				wavyVert++;
+				wavyNormal++;
 			}
 		}
 		
@@ -189,61 +322,112 @@ CWaterLevel::CreateWavyAtomic()
 		RpGeometryUnlock(wavyGeometry);
 	}
 	
-	
 	{
-		wavyFrame = RwFrameCreate();
-		ASSERT( wavyFrame != NULL );
+		maskMorphTarget = RpGeometryGetMorphTarget(maskGeometry, 0);
+		maskVert = RpMorphTargetGetVertices(maskMorphTarget);
+		maskNormal = RpMorphTargetGetVertexNormals(maskMorphTarget);
 		
-		ms_pWavyAtomic = RpAtomicCreate();		
-		ASSERT( ms_pWavyAtomic != NULL );
+		for ( int32 i = 0; i < 33; i++ )
+		{
+			for ( int32 j = 0; j < 33; j++ )
+			{
+				(*maskVert).x = (float)i * 2.0f;
+				(*maskVert).y = (float)j * 2.0f;
+				(*maskVert).z = 0.0f;
+				
+				(*maskNormal).x = 0.0f;
+				(*maskNormal).y = 0.0f;
+				(*maskNormal).z = 1.0f;
+				
+				maskVert++;
+				maskNormal++;
+			}
+		}
 		
+		RpMorphTargetCalcBoundingSphere(maskMorphTarget, &boundingSphere);
+		RpMorphTargetSetBoundingSphere(maskMorphTarget, &boundingSphere);
+		RpGeometryUnlock(maskGeometry);
+	}
+	
+	{
+		wavyFrame = RwFrameCreate();
+		ms_pWavyAtomic = RpAtomicCreate();
 		RpAtomicSetGeometry(ms_pWavyAtomic, wavyGeometry, 0);
 		RpAtomicSetFrame(ms_pWavyAtomic, wavyFrame);
 		RpMaterialDestroy(wavyMaterial);
 		RpGeometryDestroy(wavyGeometry);
 	}
+	
+	{
+		maskFrame = RwFrameCreate();
+		ms_pMaskAtomic = RpAtomicCreate();
+		RpAtomicSetGeometry(ms_pMaskAtomic, maskGeometry, 0);
+		RpAtomicSetFrame(ms_pMaskAtomic, maskFrame);
+		RpMaterialDestroy(maskMaterial);
+		RpGeometryDestroy(maskGeometry);
+	}
+	
+	static RwFrame *wakeEnvFrame;
+	
+	if ( wakeEnvFrame == nil )
+	{
+		wakeEnvFrame = RwFrameCreate();
+		RwMatrixSetIdentity(RwFrameGetMatrix(wakeEnvFrame));
+		RwFrameUpdateObjects(wakeEnvFrame);
+	}
+	
+	RpMatFXMaterialSetEffects(maskMaterial, rpMATFXEFFECTENVMAP);
+	RpMatFXMaterialSetupEnvMap(maskMaterial, gpWaterEnvTex, wakeEnvFrame, TRUE, fEnvScale);
+	RpMatFXAtomicEnableEffects(ms_pMaskAtomic);
 }
 
 void
 CWaterLevel::DestroyWavyAtomic()
 {
-	RwFrame *frame;
-	
-	frame = RpAtomicGetFrame(ms_pWavyAtomic);
-	
-	RpAtomicDestroy(ms_pWavyAtomic);
+#define _DELETE_ATOMIC(a) \
+		{ \
+			RwFrame *frame; \
+			frame = RpAtomicGetFrame(a); \
+			RpAtomicDestroy(a); \
+			RwFrameDestroy(frame); \
+		}
+
+	_DELETE_ATOMIC(ms_pWavyAtomic);
+	_DELETE_ATOMIC(ms_pMaskAtomic);
 	
-	RwFrameDestroy(frame);	
+#undef _DELETE_ATOMIC
 }
 
 bool
 CWaterLevel::GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool bDontCheckZ)
 {
-	int32 x = WATER_HUGE_X(fX + WATER_X_OFFSET);
-	int32 y = WATER_HUGE_Y(fY);
-	
-	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
-	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
+	int32 x = WATER_TO_SMALL_SECTOR_X(fX + WATER_X_OFFSET);
+	int32 y = WATER_TO_SMALL_SECTOR_Y(fY);
+		
+#ifdef FIX_BUGS
+	if ( x < 0 || x >= MAX_SMALL_SECTORS ) return false;
+	if ( y < 0 || y >= MAX_SMALL_SECTORS ) return false;
+#endif
 
 	uint8 nBlock = aWaterFineBlockList[x][y];
 
-	if ( nBlock == 128 )
+	if ( nBlock == 0x80 )
 		return false;
 
-	ASSERT( pfOutLevel != NULL );
+	ASSERT( pfOutLevel != nil );
 	*pfOutLevel = ms_aWaterZs[nBlock];
 
 	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
 	
 	float fWave = Sin
 	(
-		( WATER_UNSIGN_Y(fY)                  - float(y) * MAX_HUGE_SECTORS
-		+ WATER_UNSIGN_X(fX + WATER_X_OFFSET) - float(x) * MAX_HUGE_SECTORS )
+		( WATER_UNSIGN_Y(fY)                  - y*SMALL_SECTOR_SIZE
+		+ WATER_UNSIGN_X(fX + WATER_X_OFFSET) - x*SMALL_SECTOR_SIZE )
 		
-		* (TWOPI / MAX_HUGE_SECTORS ) + fAngle
+		* (TWOPI / SMALL_SECTOR_SIZE ) + fAngle
 	);
 
-	float fWindFactor = CWeather::Wind * 0.7f + 0.3f;
+	float fWindFactor = CWeather::WindClipped * 0.4f + 0.2f;
 	
 	*pfOutLevel += fWave * fWindFactor;
 
@@ -259,35 +443,69 @@ CWaterLevel::GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool
 bool
 CWaterLevel::GetWaterLevelNoWaves(float fX, float fY, float fZ, float *pfOutLevel)
 {
-	int32 x = WATER_HUGE_X(fX + WATER_X_OFFSET);
-	int32 y = WATER_HUGE_Y(fY);
-	
-	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
-	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
+	int32 x = WATER_TO_SMALL_SECTOR_X(fX + WATER_X_OFFSET);
+	int32 y = WATER_TO_SMALL_SECTOR_Y(fY);
+		
+#ifdef FIX_BUGS
+	if ( x < 0 || x >= MAX_SMALL_SECTORS ) return false;
+	if ( y < 0 || y >= MAX_SMALL_SECTORS ) return false;
+#endif
 	
 	uint8 nBlock = aWaterFineBlockList[x][y];
 		
-	if ( nBlock == 128 )
+	if ( nBlock == 0x80 )
 		return false;
 	
-	ASSERT( pfOutLevel != NULL );
+	ASSERT( pfOutLevel != nil );
 	*pfOutLevel = ms_aWaterZs[nBlock];
 
 	return true;
 }
 
-inline float
-_GetWaterDrawDist()
+float
+CWaterLevel::GetWaterWavesOnly(short x, short y)
 {
-	// if z less then 15.0f return 1200.0f 
-	if ( TheCamera.GetPosition().z < 15.0f )
-		return 1200.0f;
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
+	
+	float fWindFactor = CWeather::WindClipped * 0.7f + 0.3f;
+	
+	float fWave = Sin( float(float(4 * y + 4 * x) * (TWOPI / SMALL_SECTOR_SIZE )) + fAngle );
+	
+	return fWave * fWindFactor;
+}
+	   
+CVector
+CWaterLevel::GetWaterNormal(float fX, float fY)
+{
+	//TODO: BUG ? no x offset
+	
+	int32 x = WATER_TO_SMALL_SECTOR_X(fX);
+	int32 y = WATER_TO_SMALL_SECTOR_Y(fY);
+	
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
+	float fWindFactor = CWeather::WindClipped * 0.4f + 0.2f;
+	
+	//TODO: 
+	float _fWave = (WATER_UNSIGN_Y(fY) - y*SMALL_SECTOR_SIZE + WATER_UNSIGN_X(fX) - x*SMALL_SECTOR_SIZE)
+			* (TWOPI / SMALL_SECTOR_SIZE ) + fAngle;
+
+	CVector vA(1.0f, 0.0f, fWindFactor * (TWOPI / SMALL_SECTOR_SIZE ) * Cos(_fWave));
+	CVector vB(0.0f, 1.0f, fWindFactor * (TWOPI / SMALL_SECTOR_SIZE ) * Cos(_fWave));
+	
+	CVector norm = CrossProduct(vA, vB);
+	
+	norm.Normalise();
+	
+	return norm;
+}
 
-	// if z greater then 60.0f return 2000.0f;
-	if ( TheCamera.GetPosition().z > 60.0f )
-		return 2000.0f;
 
-	return (TheCamera.GetPosition().z + -15.0f) * 800.0f / 45.0f + 1200.0f;
+inline float
+_GetWaterDrawDist()
+{
+	if     ( TheCamera.GetPosition().z < 15.0f  ) return 1200.0f;
+	if     ( TheCamera.GetPosition().z > 60.0f  ) return 2000.0f;
+	return ( TheCamera.GetPosition().z + -15.0f ) * 800.0f / 45.0f + 1200.0f;
 }
 
 inline float
@@ -321,6 +539,49 @@ _GetCamBounds(bool *bUseCamStartY, bool *bUseCamEndY, bool *bUseCamStartX, bool
 	}
 }
 
+
+inline bool 
+_IsColideWithBlock(int32 x, int32 y, int32 &block)
+{
+	block = CWaterLevel::aWaterFineBlockList[x + 0][y + 0];
+	if (!(block & 0x80))
+		return true;
+
+	block = CWaterLevel::aWaterFineBlockList[x + 0][y + 1];
+	if (!(block & 0x80))
+	{
+		block = CWaterLevel::aWaterFineBlockList[x + 0][y + 2];
+		if (!(block & 0x80))
+			return true;
+	}
+
+	block = CWaterLevel::aWaterFineBlockList[x + 1][y + 0];
+	if (!(block & 0x80))
+		return true;
+
+	block = CWaterLevel::aWaterFineBlockList[x + 1][y + 1];
+	if (!(block & 0x80))
+	{
+		block = CWaterLevel::aWaterFineBlockList[x + 1][y + 2];
+		if (!(block & 0x80))
+			return true;
+	}
+
+	block = CWaterLevel::aWaterFineBlockList[x + 2][y + 0];
+	if (!(block & 0x80))
+		return true;
+
+	block = CWaterLevel::aWaterFineBlockList[x + 2][y + 1];
+	if (!(block & 0x80))
+	{
+		block = CWaterLevel::aWaterFineBlockList[x + 2][y + 2];
+		if (!(block & 0x80))
+			return true;
+	}
+
+	return false;
+}
+
 inline float
 SectorRadius(float fSize)
 {
@@ -336,34 +597,48 @@ CWaterLevel::RenderWater()
 	bool bUseCamStartX = false;
 	bool bUseCamEndY   = false;
 	
-	float fWavySectorMaxRenderDist      = _GetWavyDrawDist();
-	float fWavySectorMaxRenderDistSqr   = SQR(fWavySectorMaxRenderDist);
+	if ( !CGame::CanSeeWaterFromCurrArea() )
+		return;
 	
 	_GetCamBounds(&bUseCamStartY, &bUseCamEndY, &bUseCamStartX, &bUseCamEndX);
 
 	float fHugeSectorMaxRenderDist    = _GetWaterDrawDist();
 	float fHugeSectorMaxRenderDistSqr = SQR(fHugeSectorMaxRenderDist);
 	
-	float windAddUV = CWeather::Wind * 0.0015f + 0.0005f;
+	float windAddUV = CWeather::WindClipped * 0.0005f + 0.0006f;
 	
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
 	
 	if ( !CTimer::GetIsPaused() )
 	{
-#ifdef FIX_BUGS
-		TEXTURE_ADDU += (CGeneral::GetRandomNumberInRange(-0.0005f, 0.0005f) + windAddUV) * CTimer::GetTimeStepFix();
-		TEXTURE_ADDV += (CGeneral::GetRandomNumberInRange(-0.0005f, 0.0005f) + windAddUV) * CTimer::GetTimeStepFix();
-#else
-		TEXTURE_ADDU += CGeneral::GetRandomNumberInRange(-0.0005f, 0.0005f) + windAddUV;
-		TEXTURE_ADDV += CGeneral::GetRandomNumberInRange(-0.0005f, 0.0005f) + windAddUV;
-#endif
+		TEXTURE_ADDU       += windAddUV;
+		TEXTURE_ADDV       += windAddUV;
+		
+		_TEXTURE_MASK_ADDU += Sin(fAngle) 		 * 0.0005f + 1.1f * windAddUV;
+		_TEXTURE_MASK_ADDV -= Cos(fAngle * 1.3f) * 0.0005f + 1.2f * windAddUV;
+		
+		_TEXTURE_WAKE_ADDU -= Sin(fAngle) 		 * 0.0003f + windAddUV;
+		_TEXTURE_WAKE_ADDV += Cos(fAngle * 0.7f) * 0.0003f + windAddUV;
 	}
 	
+	if ( _TEXTURE_MASK_ADDU >= 1.0f )
+		_TEXTURE_MASK_ADDU = 0.0f;
+	if ( _TEXTURE_MASK_ADDV >= 1.0f )
+		_TEXTURE_MASK_ADDV = 0.0f;
+	
+	if ( _TEXTURE_WAKE_ADDU >= 1.0f )
+		_TEXTURE_WAKE_ADDU = 0.0f;
+	if ( _TEXTURE_WAKE_ADDV >= 1.0f )
+		_TEXTURE_WAKE_ADDV = 0.0f;
+	
 	if ( TEXTURE_ADDU >= 1.0f )
 		TEXTURE_ADDU = 0.0f;
 	if ( TEXTURE_ADDV >= 1.0f )
 		TEXTURE_ADDV = 0.0f;
 	
-	WavesCalculatedThisFrame = false;
+#ifdef PC_WATER
+	_fWaterZOffset = CWeather::WindClipped * 0.5f + 0.25f;
+#endif
 
 	RwRGBA color = { 0, 0, 0, 255 };
 
@@ -371,25 +646,32 @@ CWaterLevel::RenderWater()
 	color.green = CTimeCycle::GetWaterGreen();
 	color.blue  = CTimeCycle::GetWaterBlue();
 
+#ifndef PC_WATER
+	RwRGBA colorUnderwater = { 0, 0, 0, 255 };
+	colorUnderwater.red = (uint32)(0.8f * (float)colorUnderwater.red);
+	colorUnderwater.green = (uint32)(0.8f * (float)colorUnderwater.green);
+	colorUnderwater.blue = (uint32)(0.8f * (float)colorUnderwater.blue);
+#endif
+
 	TempBufferVerticesStored = 0;
 	TempBufferIndicesStored = 0;
+
+#ifndef PC_WATER
+	WavesCalculatedThisFrame = false;
+#endif
 	
 	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)gpWaterRaster);
 	RwRenderStateSet(rwRENDERSTATEFOGENABLE,     (void *)TRUE);
 	RwRenderStateSet(rwRENDERSTATESRCBLEND,      (void *)rwBLENDONE);
 	RwRenderStateSet(rwRENDERSTATEDESTBLEND,     (void *)rwBLENDZERO);
 	
-	CVector2D camPos
-	(
-		TheCamera.GetPosition().x,
-		TheCamera.GetPosition().y
-	);
+	CVector2D camPos(TheCamera.GetPosition().x, TheCamera.GetPosition().y);
 
 	int32 nStartX = WATER_TO_HUGE_SECTOR_X(camPos.x - fHugeSectorMaxRenderDist + WATER_X_OFFSET);
 	int32 nEndX   = WATER_TO_HUGE_SECTOR_X(camPos.x + fHugeSectorMaxRenderDist + WATER_X_OFFSET) + 1;
 	int32 nStartY = WATER_TO_HUGE_SECTOR_Y(camPos.y - fHugeSectorMaxRenderDist);
 	int32 nEndY   = WATER_TO_HUGE_SECTOR_Y(camPos.y + fHugeSectorMaxRenderDist) + 1;
-
+	
 	if ( bUseCamStartX )
 		nStartX = WATER_TO_HUGE_SECTOR_X(camPos.x + WATER_X_OFFSET);
 	if ( bUseCamEndX )
@@ -408,184 +690,53 @@ CWaterLevel::RenderWater()
 	{
 		for ( int32 y = nStartY; y <= nEndY; y++ )
 		{
-			if (   !(aWaterBlockList[2*x+0][2*y+0] & 128)
-				|| !(aWaterBlockList[2*x+1][2*y+0] & 128)
-				|| !(aWaterBlockList[2*x+0][2*y+1] & 128)
-				|| !(aWaterBlockList[2*x+1][2*y+1] & 128) )
+			if (   !(aWaterBlockList[2*x+0][2*y+0] & 0x80)
+				|| !(aWaterBlockList[2*x+1][2*y+0] & 0x80)
+				|| !(aWaterBlockList[2*x+0][2*y+1] & 0x80)
+				|| !(aWaterBlockList[2*x+1][2*y+1] & 0x80) )
 			{
 				float fX = WATER_FROM_HUGE_SECTOR_X(x) - WATER_X_OFFSET;
 				float fY = WATER_FROM_HUGE_SECTOR_Y(y);
 
-				CVector2D vecHugeSectorCentre
-				(
-					fX + HUGE_SECTOR_SIZE/2,
-					fY + HUGE_SECTOR_SIZE/2
-				);
+				CVector2D vecHugeSectorCentre(fX + HUGE_SECTOR_SIZE/2,fY + HUGE_SECTOR_SIZE/2);
 
 				float fHugeSectorDistToCamSqr = (camPos - vecHugeSectorCentre).MagnitudeSqr();
-
+				
 				if ( fHugeSectorMaxRenderDistSqr > fHugeSectorDistToCamSqr )
 				{
-					if ( TheCamera.IsSphereVisible(CVector(vecHugeSectorCentre.x, vecHugeSectorCentre.y, 0.0f), SectorRadius(HUGE_SECTOR_SIZE),
-							&TheCamera.GetCameraMatrix()) )
+					if ( TheCamera.IsSphereVisible(CVector(vecHugeSectorCentre.x, vecHugeSectorCentre.y, 0.0f), SectorRadius(HUGE_SECTOR_SIZE), &TheCamera.GetCameraMatrix()) )
 					{
-						if ( fHugeSectorDistToCamSqr >= SQR(500.0f) /*fHugeSectorNearDist*/ )
+#ifndef PC_WATER
+						WavesCalculatedThisFrame = true;
+#endif
+
+
+						float fZ;
+
+						if ( !(aWaterBlockList[2*x+0][2*y+0] & 0x80) )
+							fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+0] ];
+
+						if ( !(aWaterBlockList[2*x+1][2*y+0] & 0x80) )
+							fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+0] ];
+
+						if ( !(aWaterBlockList[2*x+0][2*y+1] & 0x80) )
+							fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+1] ];
+
+						if ( !(aWaterBlockList[2*x+1][2*y+1] & 0x80) )
+							fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+1] ];
+						
+						if ( fHugeSectorDistToCamSqr >= SQR(500.0f) )
 						{
-							float fZ;
-	
-							if ( !(aWaterBlockList[2*x+0][2*y+0] & 128) )
-								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+0] ];
-	
-							if ( !(aWaterBlockList[2*x+1][2*y+0] & 128) )
-								fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+0] ];
-	
-							if ( !(aWaterBlockList[2*x+0][2*y+1] & 128) )
-								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+1] ];
-	
-							if ( !(aWaterBlockList[2*x+1][2*y+1] & 128) )
-								fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+1] ];
-							
 							RenderOneFlatHugeWaterPoly(fX, fY, fZ, color);
 						}
 						else
 						{
-							for ( int32 x2 = 2*x; x2 <= 2*x+1; x2++ )
-							{
-								for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
-								{
-									if ( !(aWaterBlockList[x2][y2] & 128) )
-									{
-										float fLargeX = WATER_FROM_LARGE_SECTOR_X(x2) - WATER_X_OFFSET;
-										float fLargeY = WATER_FROM_LARGE_SECTOR_Y(y2);
-						
-										CVector2D vecLargeSectorCentre
-										(
-											fLargeX + LARGE_SECTOR_SIZE/2,
-											fLargeY + LARGE_SECTOR_SIZE/2
-										);
-										
-										float fLargeSectorDistToCamSqr = (camPos - vecLargeSectorCentre).MagnitudeSqr();
-										
-										if ( fLargeSectorDistToCamSqr < fHugeSectorMaxRenderDistSqr )
-										{
-											if ( TheCamera.IsSphereVisible(CVector(vecLargeSectorCentre.x, vecLargeSectorCentre.y, 0.0f), SectorRadius(LARGE_SECTOR_SIZE), //90.879997f,
-												&TheCamera.GetCameraMatrix()) )
-											{
-												// Render four small(32x32) sectors, or one large(64x64).
-
-												//														
-												//	       [N]
-												//	    ---------
-												//	    |0x1|1x1|
-												//	[W] --------- [E]
-												//	    |0x0|1x0|
-												//	    ---------
-												//	       [S]
-												//	
-
-												if ( fLargeSectorDistToCamSqr < SQR(176.0f) )
-												{						
-													float fZ;
-													
-													// WS
-													if ( !(aWaterFineBlockList[2*x2+0][2*y2+0] & 128) )
-													{
-														float fSmallX = fLargeX;
-														float fSmallY = fLargeY;
-														
-														CVector2D vecSmallSectorCentre
-														(
-															fSmallX + SMALL_SECTOR_SIZE/2,
-															fSmallY + SMALL_SECTOR_SIZE/2
-														);
-														
-														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
-														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+0][2*y2+0] ];
-														
-														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
-															RenderOneWavySector(fSmallX, fSmallY, fZ, color);
-														else
-															RenderOneFlatSmallWaterPoly(fSmallX, fSmallY, fZ, color);
-													}
-													
-													// SE
-													if ( !(aWaterFineBlockList[2*x2+1][2*y2+0] & 128) )
-													{
-														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
-														float fSmallY = fLargeY;
-														
-														CVector2D vecSmallSectorCentre
-														(
-															fSmallX + SMALL_SECTOR_SIZE/2,
-															fSmallY + SMALL_SECTOR_SIZE/2
-														);
-														
-														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
-														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+1][2*y2+0] ];
-														
-														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
-															RenderOneWavySector(fSmallX, fSmallY, fZ, color);
-														else
-															RenderOneFlatSmallWaterPoly(fSmallX, fSmallY, fZ, color);
-													}
-													
-													// WN
-													if ( !(aWaterFineBlockList[2*x2+0][2*y2+1] & 128) )
-													{
-														float fSmallX = fLargeX;
-														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
-														
-														CVector2D vecSmallSectorCentre
-														(
-															fSmallX + SMALL_SECTOR_SIZE/2,
-															fSmallY + SMALL_SECTOR_SIZE/2
-														);
-														
-														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
-														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+0][2*y2+1] ];
-														
-														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
-															RenderOneWavySector(fSmallX, fSmallY, fZ, color);
-														else
-															RenderOneFlatSmallWaterPoly(fSmallX, fSmallY, fZ, color);
-													}
-													
-													//NE
-													if ( !(aWaterFineBlockList[2*x2+1][2*y2+1] & 128) )
-													{
-														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
-														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
-														
-														CVector2D vecSmallSectorCentre
-														(
-															fSmallX + SMALL_SECTOR_SIZE/2,
-															fSmallY + SMALL_SECTOR_SIZE/2
-														);
-														
-														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
-														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+1][2*y2+1] ];
-														
-														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
-															RenderOneWavySector(fSmallX, fSmallY, fZ, color);
-														else
-															RenderOneFlatSmallWaterPoly(fSmallX, fSmallY, fZ, color);
-													}
-												}
-												else
-												{
-													float fZ;
-                                                
-													fZ = ms_aWaterZs[ aWaterBlockList[x2][y2] ];
-                                                
-													RenderOneFlatLargeWaterPoly(fLargeX, fLargeY, fZ, color);
-												}
-											}	//	if ( TheCamera.IsSphereVisible
-										}	//	if ( fLargeSectorDistToCamSqr < fHugeSectorMaxRenderDistSqr )
-									}	//	if ( !(aWaterBlockList[x2][y2] & 128) )
-								}	//	for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
-							}	//	for ( int32 x2 = 2*x; x2 <= 2*x+1; x2++ )
-							//
-							
+#ifndef PC_WATER
+							if (m_bRenderSeaBed)
+								RenderOneSlopedUnderWaterPoly(fX, fY, fZ, colorUnderwater);
+#endif
+							// see RenderTransparentWater()
+							;
 						}
 					}
 				}
@@ -621,11 +772,7 @@ CWaterLevel::RenderWater()
 			
 			if ( !bUseCamStartY )
 			{
-				CVector2D vecExtraHugeSectorCentre
-				(
-					fX + EXTRAHUGE_SECTOR_SIZE/2,
-					fY + EXTRAHUGE_SECTOR_SIZE/2
-				);
+				CVector2D vecExtraHugeSectorCentre(fX + EXTRAHUGE_SECTOR_SIZE/2, fY + EXTRAHUGE_SECTOR_SIZE/2);
 				
 				float fCamDistToSector = (vecExtraHugeSectorCentre - camPos).Magnitude();
 				
@@ -644,11 +791,7 @@ CWaterLevel::RenderWater()
 			
 			if ( !bUseCamEndY )
 			{
-				CVector2D vecExtraHugeSectorCentre
-				(
-					fX + EXTRAHUGE_SECTOR_SIZE/2,
-					-(fY + EXTRAHUGE_SECTOR_SIZE/2)
-				);
+				CVector2D vecExtraHugeSectorCentre(fX + EXTRAHUGE_SECTOR_SIZE/2, -(fY + EXTRAHUGE_SECTOR_SIZE/2));
 				
 				float fCamDistToSector = (vecExtraHugeSectorCentre - camPos).Magnitude();
 				
@@ -664,7 +807,6 @@ CWaterLevel::RenderWater()
 					}
 				}
 			}
-
 		}
 	}
 	
@@ -672,17 +814,13 @@ CWaterLevel::RenderWater()
 	{
 		for ( int32 x = 0; x < 5; x++ )
 		{
-			float fX = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f - 400.0f;
-			float fX2 = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f + 400.0f;
-			float fY = WATER_SIGN_Y(float(y) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f;
+			float fX = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE)  - 1280.0f - WATER_X_OFFSET;
+			float fX2 = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f + WATER_X_OFFSET;
+			float fY = WATER_SIGN_Y(float(y) * EXTRAHUGE_SECTOR_SIZE)  - 1280.0f;
 			
 			if ( !bUseCamStartX )
 			{
-				CVector2D vecExtraHugeSectorCentre
-				(
-					fX + EXTRAHUGE_SECTOR_SIZE/2,
-					fY + EXTRAHUGE_SECTOR_SIZE/2
-				);
+				CVector2D vecExtraHugeSectorCentre(fX + EXTRAHUGE_SECTOR_SIZE/2, fY + EXTRAHUGE_SECTOR_SIZE/2);
 				
 				float fCamDistToSector = (vecExtraHugeSectorCentre - camPos).Magnitude();
 				
@@ -701,17 +839,13 @@ CWaterLevel::RenderWater()
 			
 			if ( !bUseCamEndX )
 			{
-				CVector2D vecExtraHugeSectorCentre
-				(
-					-(fX2 + EXTRAHUGE_SECTOR_SIZE/2),
-					fY + EXTRAHUGE_SECTOR_SIZE/2
-				);
+				CVector2D vecExtraHugeSectorCentre(-(fX2 + EXTRAHUGE_SECTOR_SIZE/2), fY + EXTRAHUGE_SECTOR_SIZE/2);
 				
 				float fCamDistToSector = (vecExtraHugeSectorCentre - camPos).Magnitude();
 				
 				if ( fCamDistToSector < fHugeSectorMaxRenderDistSqr )
 				{
-					if ( TheCamera.IsSphereVisible(CVector(vecExtraHugeSectorCentre.x, vecExtraHugeSectorCentre.y, 0.0f), SectorRadius(EXTRAHUGE_SECTOR_SIZE), &TheCamera.GetCameraMatrix()) )
+					if ( TheCamera.IsSphereVisible(CVector(vecExtraHugeSectorCentre.x, vecExtraHugeSectorCentre.x, 0.0f), SectorRadius(EXTRAHUGE_SECTOR_SIZE), &TheCamera.GetCameraMatrix()) )
 					{
 						RenderOneFlatExtraHugeWaterPoly(
 							vecExtraHugeSectorCentre.x - EXTRAHUGE_SECTOR_SIZE/2,
@@ -723,86 +857,352 @@ CWaterLevel::RenderWater()
 			}
 		}
 	}
-
-	RenderAndEmptyRenderBuffer();
 	
-	CVector cur_pos = TheCamera.GetPosition();
+	RenderAndEmptyRenderBuffer();
+
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
 	
-	if ( !CCullZones::CamNoRain()
-		&& !CCullZones::PlayerNoRain()
-		&& CWeather::NewWeatherType == WEATHER_SUNNY
-		&& CClock::GetHours() > 6 && CClock::GetHours() < 20
-		&& WavesCalculatedThisFrame)
+	if ( WavesCalculatedThisFrame )
 	{
-		static CVector prev_pos(0.0f, 0.0f, 0.0f);
-		static CVector prev_front(0.0f, 0.0f, 0.0f);
-		static int32 timecounter;
+		RenderSeaBirds();
+		RenderShipsOnHorizon();
+		CParticle::HandleShipsAtHorizonStuff();
+		HandleBeachToysStuff();
+	}
+	
+	if ( _bSeaLife )
+		HandleSeaLifeForms();
 
-		if ( Abs(prev_pos.x - cur_pos.x) + Abs(prev_pos.y - cur_pos.y) + Abs(prev_pos.z - cur_pos.z) > 1.5f )
-		{
-			prev_pos = cur_pos;
-			timecounter = CTimer::GetTimeInMilliseconds();
-		}
-		else if ( CTimer::GetTimeInMilliseconds() - timecounter > 5000 )
+	DefinedState();
+}
+
+
+void
+CWaterLevel::RenderTransparentWater(void)
+{
+	bool bUseCamEndX  = false;
+	bool bUseCamStartY = false;
+	
+	bool bUseCamStartX = false;
+	bool bUseCamEndY   = false;
+	
+	_bSeaLife = false;
+	
+	if ( !CGame::CanSeeWaterFromCurrArea() )
+		return;
+	
+	float fWaterDrawDist      = _GetWavyDrawDist();
+	float fWaterDrawDistLarge = fWaterDrawDist + 90.0f;
+	float fWavySectorMaxRenderDistSqr   = SQR(fWaterDrawDist);
+	
+	_GetCamBounds(&bUseCamStartY, &bUseCamEndY, &bUseCamStartX, &bUseCamEndX);
+
+	float fHugeSectorMaxRenderDist    = _GetWaterDrawDist();
+	float fHugeSectorMaxRenderDistSqr = SQR(fHugeSectorMaxRenderDist);
+	
+	RenderBoatWakes();
+	
+	RwRGBA color;
+	
+	color.red   = CTimeCycle::GetWaterRed();
+	color.green = CTimeCycle::GetWaterGreen();
+	color.blue  = CTimeCycle::GetWaterBlue();
+	color.alpha = 255;
+	
+	RwRGBA colorTrans;
+	
+	colorTrans.red   = CTimeCycle::GetWaterRed();
+	colorTrans.green = CTimeCycle::GetWaterGreen();
+	colorTrans.blue  = CTimeCycle::GetWaterBlue();
+	colorTrans.alpha = CTimeCycle::GetWaterAlpha();
+	
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+
+#ifndef PC_WATER
+	WavesCalculatedThisFrame = false;
+#endif
+	
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)gpWaterRaster);
+#ifndef PC_WATER
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+#endif
+	
+	CVector2D camPos(TheCamera.GetPosition().x, TheCamera.GetPosition().y);
+
+	int32 nStartX = WATER_TO_HUGE_SECTOR_X(camPos.x - fHugeSectorMaxRenderDist + WATER_X_OFFSET);
+	int32 nEndX   = WATER_TO_HUGE_SECTOR_X(camPos.x + fHugeSectorMaxRenderDist + WATER_X_OFFSET) + 1;
+	int32 nStartY = WATER_TO_HUGE_SECTOR_Y(camPos.y - fHugeSectorMaxRenderDist         );
+	int32 nEndY   = WATER_TO_HUGE_SECTOR_Y(camPos.y + fHugeSectorMaxRenderDist         ) + 1;
+
+	if ( bUseCamStartX )
+		nStartX = WATER_TO_HUGE_SECTOR_X(camPos.x + WATER_X_OFFSET);
+	if ( bUseCamEndX )
+		nEndX   = WATER_TO_HUGE_SECTOR_X(camPos.x + WATER_X_OFFSET);
+	if ( bUseCamStartY )
+		nStartY = WATER_TO_HUGE_SECTOR_Y(camPos.y         );
+	if ( bUseCamEndY )                                      
+		nEndY   = WATER_TO_HUGE_SECTOR_Y(camPos.y         );
+	
+	nStartX = clamp(nStartX, 0, MAX_HUGE_SECTORS - 1);
+	nEndX   = clamp(nEndX,   0, MAX_HUGE_SECTORS - 1);
+	nStartY = clamp(nStartY, 0, MAX_HUGE_SECTORS - 1);
+	nEndY   = clamp(nEndY,   0, MAX_HUGE_SECTORS - 1);
+	
+	
+	for ( int32 x = nStartX; x <= nEndX; x++ )
+	{
+		for ( int32 y = nStartY; y <= nEndY; y++ )
 		{
-			static int32 birdgenTime = 0;
-			
-			if ( CTimer::GetTimeInMilliseconds() - birdgenTime > 1000 )
+			if (   !(aWaterBlockList[2*x+0][2*y+0] & 0x80)
+				|| !(aWaterBlockList[2*x+1][2*y+0] & 0x80)
+				|| !(aWaterBlockList[2*x+0][2*y+1] & 0x80)
+				|| !(aWaterBlockList[2*x+1][2*y+1] & 0x80) )
 			{
-				birdgenTime = CTimer::GetTimeInMilliseconds();
-				
-				CVector vecPos = cur_pos;
-				
-				float fAngle = CGeneral::GetRandomNumberInRange(90.0f, 150.0f);
-				
-				int32 nRot = CGeneral::GetRandomNumber() % CParticle::SIN_COS_TABLE_SIZE-1;
-				
-				float fCos = CParticle::Cos(nRot);
-				float fSin = CParticle::Sin(nRot);
+				float fX = WATER_FROM_HUGE_SECTOR_X(x) - WATER_X_OFFSET;
+				float fY = WATER_FROM_HUGE_SECTOR_Y(y);
 
-				vecPos.x += (fCos - fSin) * fAngle;
-				vecPos.y += (fSin + fCos) * fAngle;
-				vecPos.z += CGeneral::GetRandomNumberInRange(10.0f, 30.0f);
-				
-				CVector vecDir(CGeneral::GetRandomNumberInRange(-1.0f, 1.0f),
-								CGeneral::GetRandomNumberInRange(-1.0f, 1.0f),
-								0.0f);
+				CVector2D vecHugeSectorCentre
+				(
+					fX + HUGE_SECTOR_SIZE/2,
+					fY + HUGE_SECTOR_SIZE/2
+				);
+
+				float fHugeSectorDistToCamSqr = (camPos - vecHugeSectorCentre).MagnitudeSqr();
 				
-				CParticle::AddParticle(PARTICLE_BIRD_FRONT, vecPos, vecDir);
+				if ( fHugeSectorMaxRenderDistSqr > fHugeSectorDistToCamSqr )
+				{
+					if ( TheCamera.IsSphereVisible(CVector(vecHugeSectorCentre.x, vecHugeSectorCentre.y, 0.0f), SectorRadius(HUGE_SECTOR_SIZE), &TheCamera.GetCameraMatrix()) )
+					{
+						if ( fHugeSectorDistToCamSqr >= SQR(500.0f) )
+						{
+							// see RenderWater()
+							;
+						}
+						else
+						{
+							for ( int32 x2 = 2*x; x2 <= 2*x+1; x2++ )
+							{
+								for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
+								{
+									if ( !(aWaterBlockList[x2][y2] & 0x80) )
+									{
+										float fLargeX = WATER_FROM_LARGE_SECTOR_X(x2) - WATER_X_OFFSET;
+										float fLargeY = WATER_FROM_LARGE_SECTOR_Y(y2);
+						
+										CVector2D vecLargeSectorCentre(fLargeX + LARGE_SECTOR_SIZE/2, fLargeY + LARGE_SECTOR_SIZE/2);
+										
+										float fLargeSectorDistToCamSqr = (camPos - vecLargeSectorCentre).MagnitudeSqr();
+										
+										if ( fLargeSectorDistToCamSqr < fHugeSectorMaxRenderDistSqr )
+										{
+											if ( TheCamera.IsSphereVisible(CVector(vecLargeSectorCentre.x, vecLargeSectorCentre.y, 0.0f), SectorRadius(LARGE_SECTOR_SIZE), &TheCamera.GetCameraMatrix()) )
+											{
+												// Render four small(32x32) sectors, or one large(64x64).
+
+												//														
+												//	       [N]
+												//	    ---------
+												//	    |0x1|1x1|
+												//	[W] --------- [E]
+												//	    |0x0|1x0|
+												//	    ---------
+												//	       [S]
+												//	
+												
+												float fLargeSectorDrawDistSqr = SQR((fWaterDrawDistLarge + 16.0f));
+												
+												if ( fLargeSectorDistToCamSqr < fLargeSectorDrawDistSqr )
+												{
+													_bSeaLife = true;
+													
+													float fZ;
+													
+													// WS
+													if ( !(aWaterFineBlockList[2*x2+0][2*y2+0] & 0x80) )
+													{
+														float fSmallX = fLargeX;
+														float fSmallY = fLargeY;
+														
+														CVector2D vecSmallSectorCentre(fSmallX + SMALL_SECTOR_SIZE/2, fSmallY + SMALL_SECTOR_SIZE/2);
+														
+														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
+														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+0][2*y2+0] ];
+														
+														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
+															RenderOneWavySector(fSmallX, fSmallY, fZ, colorTrans);
+														else
+															RenderOneFlatSmallWaterPolyBlended(fSmallX, fSmallY, fZ, camPos.x, camPos.y, color, colorTrans, fWaterDrawDist);
+													}
+													
+													// SE
+													if ( !(aWaterFineBlockList[2*x2+1][2*y2+0] & 0x80) )
+													{
+														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
+														float fSmallY = fLargeY;
+														
+														CVector2D vecSmallSectorCentre(fSmallX + SMALL_SECTOR_SIZE/2, fSmallY + SMALL_SECTOR_SIZE/2);
+														
+														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
+														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+1][2*y2+0] ];
+														
+														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
+															RenderOneWavySector(fSmallX, fSmallY, fZ, colorTrans);
+														else
+															RenderOneFlatSmallWaterPolyBlended(fSmallX, fSmallY, fZ, camPos.x, camPos.y, color, colorTrans, fWaterDrawDist);
+													}
+													
+													// WN
+													if ( !(aWaterFineBlockList[2*x2+0][2*y2+1] & 0x80) )
+													{
+														float fSmallX = fLargeX;
+														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
+														
+														CVector2D vecSmallSectorCentre(fSmallX + SMALL_SECTOR_SIZE/2,fSmallY + SMALL_SECTOR_SIZE/2);
+														
+														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
+														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+0][2*y2+1] ];
+														
+														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
+															RenderOneWavySector(fSmallX, fSmallY, fZ, colorTrans);
+														else
+															RenderOneFlatSmallWaterPolyBlended(fSmallX, fSmallY, fZ, camPos.x, camPos.y, color, colorTrans, fWaterDrawDist);
+													}
+													
+													//NE
+													if ( !(aWaterFineBlockList[2*x2+1][2*y2+1] & 0x80) )
+													{
+														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
+														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
+														
+														CVector2D vecSmallSectorCentre(fSmallX + SMALL_SECTOR_SIZE/2, fSmallY + SMALL_SECTOR_SIZE/2);
+														
+														float fSmallSectorDistToCamSqr = (camPos - vecSmallSectorCentre).MagnitudeSqr();
+														fZ = ms_aWaterZs[ aWaterFineBlockList[2*x2+1][2*y2+1] ];
+														
+														if ( fSmallSectorDistToCamSqr < fWavySectorMaxRenderDistSqr )
+															RenderOneWavySector(fSmallX, fSmallY, fZ, colorTrans);
+														else
+															RenderOneFlatSmallWaterPolyBlended(fSmallX, fSmallY, fZ, camPos.x, camPos.y, color, colorTrans, fWaterDrawDist);
+													}
+												}
+												else
+												{
+													float fZ;
+                                                
+													fZ = ms_aWaterZs[ aWaterBlockList[x2][y2] ];
+                                                
+													RenderOneFlatLargeWaterPoly(fLargeX, fLargeY, fZ, color);
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
 			}
 		}
 	}
 	
+	RenderAndEmptyRenderBuffer();
+	
+#ifdef PC_WATER
+	if ( MaskCalculatedThisFrame
+		&& (m_nRenderWaterLayers == 0 || m_nRenderWaterLayers == 2 || m_nRenderWaterLayers == 3) )
+	{
+		RwV3d pos = { 0.0f, 0.0f, 0.0f };
+
+		pos.x = PreCalculatedMaskPosn.x;
+		pos.y = PreCalculatedMaskPosn.y;
+		pos.z = PreCalculatedMaskPosn.z;
+
+		RpMatFXMaterialSetEnvMapFrame(RpGeometryGetMaterial(RpAtomicGetGeometry(ms_pMaskAtomic), 0),
+										RwCameraGetFrame(RwCameraGetCurrentCamera()));
+
+		RwFrameTranslate(RpAtomicGetFrame(ms_pMaskAtomic), &pos, rwCOMBINEREPLACE);
+				
+		RpAtomicRender(ms_pMaskAtomic);
+	}
+#else
+	if (!CCullZones::WaterFudge())
+	{
+		int32 signX = 0;
+		int32 signY = 0;
+
+		float fCamX = camPos.x - SMALL_SECTOR_SIZE;
+		float fCamY = camPos.y - SMALL_SECTOR_SIZE;
+
+		if (TheCamera.GetForward().x > 0.3f)
+			signX = 1;
+		else if (TheCamera.GetForward().x < -0.3f)
+			signX = -1;
+
+		fCamX += 0.3f * (float)signX * float(SMALL_SECTOR_SIZE * 2.0f); // 19.2f
+
+		if (TheCamera.GetForward().y > 0.3f)
+			signY = 1;
+		else if (TheCamera.GetForward().y < -0.3f)
+			signY = -1;
+
+		fCamY += 0.3f * (float)signY * float(SMALL_SECTOR_SIZE * 2.0f); // 19.2f
+
+		int32 nBlock;
+
+		int32 BlockX = WATER_TO_SMALL_SECTOR_X(fCamX + 400.0f) + 1;
+		int32 BlockY = WATER_TO_SMALL_SECTOR_Y(fCamY) + 1;
+
+		if (_IsColideWithBlock(BlockX, BlockY, nBlock))
+		{
+			if (m_nRenderWaterLayers != 1 && m_nRenderWaterLayers != 6)
+			{
+				float fMaskX = floorf(fCamX / 2.0f) * 2.0f;
+				float fMaskY = floorf(fCamY / 2.0f) * 2.0f;
+				float fWaterZ = CWaterLevel::ms_aWaterZs[nBlock];
+				float fSectorX = WATER_FROM_SMALL_SECTOR_X(BlockX) - 400.0f;
+				float fSectorY = WATER_FROM_SMALL_SECTOR_Y(BlockY);
+
+				RenderWavyMask(fMaskX, fMaskY, fWaterZ,
+					fSectorX, fSectorY,
+					signX, signY, colorTrans);
+			}
+		}
+	}
+
 	DefinedState();
+#endif
 }
 
-void
-CWaterLevel::RenderOneFlatSmallWaterPoly(float fX, float fY, float fZ, RwRGBA const &color)
+void CWaterLevel::RenderOneFlatSmallWaterPoly(float fX, float fY, float fZ, RwRGBA const &color)
 {
 	if ( TempBufferIndicesStored >= TEMPBUFFERINDEXSIZE-6 || TempBufferVerticesStored >= TEMPBUFFERVERTSIZE-4 )
 		RenderAndEmptyRenderBuffer();
 	
 	int32 vidx = TempBufferVerticesStored;
 	
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 0], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + SMALL_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + SMALL_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDV + 1.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 1], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + SMALL_SECTOR_SIZE, fY + SMALL_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + SMALL_SECTOR_SIZE, fY + SMALL_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDU + 1.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDV + 1.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 2], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + SMALL_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + SMALL_SECTOR_SIZE, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDU + 1.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 3], color);
 	
 	
 	int32 iidx = TempBufferIndicesStored;
@@ -826,25 +1226,25 @@ CWaterLevel::RenderOneFlatLargeWaterPoly(float fX, float fY, float fZ, RwRGBA co
 	
 	int32 vidx = TempBufferVerticesStored;
 	
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 0], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + LARGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + LARGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDV + 2.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 1], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + LARGE_SECTOR_SIZE, fY + LARGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + LARGE_SECTOR_SIZE, fY + LARGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDU + 2.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDV + 2.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 2], color);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + LARGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + LARGE_SECTOR_SIZE, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDU + 2.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue, color.alpha);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 3], color);
 
 
 	int32 iidx = TempBufferIndicesStored;
@@ -867,27 +1267,33 @@ CWaterLevel::RenderOneFlatHugeWaterPoly(float fX, float fY, float fZ, RwRGBA con
 		RenderAndEmptyRenderBuffer();
 	
 	int32 vidx = TempBufferVerticesStored;
-
 	
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - WATER_Z_OFFSET);
+	RwRGBA c;
+	
+	c.red = color.red;
+	c.green = color.green;
+	c.blue = color.blue;
+	c.alpha = 255;
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 0], c);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + HUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + HUGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDV + 4.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 1], c);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + HUGE_SECTOR_SIZE, fY + HUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + HUGE_SECTOR_SIZE, fY + HUGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDU + 4.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDV + 4.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 2], c);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + HUGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + HUGE_SECTOR_SIZE, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDU + 4.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 3], c);
 
 
 	int32 iidx = TempBufferIndicesStored;
@@ -910,27 +1316,33 @@ CWaterLevel::RenderOneFlatExtraHugeWaterPoly(float fX, float fY, float fZ, RwRGB
 		RenderAndEmptyRenderBuffer();
 	
 	int32 vidx = TempBufferVerticesStored;
-
 	
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - WATER_Z_OFFSET);
+	RwRGBA c;
+	
+	c.red = color.red;
+	c.green = color.green;
+	c.blue = color.blue;
+	c.alpha = 255;
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 0], c);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + EXTRAHUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + EXTRAHUGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDU);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDV + 8.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 1], c);
 
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + EXTRAHUGE_SECTOR_SIZE, fY + EXTRAHUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + EXTRAHUGE_SECTOR_SIZE, fY + EXTRAHUGE_SECTOR_SIZE, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDU + 8.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDV + 8.0f);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 2], c);
 	
-	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + EXTRAHUGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + EXTRAHUGE_SECTOR_SIZE, fY, fZ - _fWaterZOffset);
 	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDU + 8.0f);
 	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDV);
-	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue, 255);
+	RwIm3DVertexSet_RGBA(&TempBufferRenderVertices[vidx + 3], c);
 
 
 	int32 iidx = TempBufferIndicesStored;
@@ -947,169 +1359,1215 @@ CWaterLevel::RenderOneFlatExtraHugeWaterPoly(float fX, float fY, float fZ, RwRGB
 }
 
 void
-CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &color, bool bUnk)
+CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &color, bool bDontRender)
 {
-	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);	
-	
-	if ( !WavesCalculatedThisFrame )
+	CVector vecSectorPos(fX + (SMALL_SECTOR_SIZE/2), fY + (SMALL_SECTOR_SIZE/2), fZ + 2.0f);
+
+	if ( COcclusion::IsAABoxOccluded(vecSectorPos, SMALL_SECTOR_SIZE, SMALL_SECTOR_SIZE, 4.0f) )
+		return;
+
+#ifdef PC_WATER
+	RequireWavySector = true;
+#else
+	if (!WavesCalculatedThisFrame)
 	{
-		nGeomUsed = 0;
-		
 		WavesCalculatedThisFrame = true;
+
+		float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
+
+		RpGeometry *wavyGeometry = RpAtomicGetGeometry(ms_pWavyAtomic);
+		RwTexCoords *wavyTexCoords = RpGeometryGetVertexTexCoords(wavyGeometry, rwTEXTURECOORDINATEINDEX0);
+		RpMorphTarget *wavyMorph = RpGeometryGetMorphTarget(wavyGeometry, 0);
+		RwRGBA *wavyPreLight = RpGeometryGetPreLightColors(wavyGeometry);
+		RwV3d *wavyMorphVerts = RpMorphTargetGetVertices(wavyMorph);
+		RwV3d *wavyMorphNormals = RpMorphTargetGetVertexNormals(wavyMorph);
+
+		RpGeometryLock(wavyGeometry, rpGEOMETRYLOCKVERTICES | rpGEOMETRYLOCKNORMALS | rpGEOMETRYLOCKPRELIGHT | rpGEOMETRYLOCKTEXCOORDS);
+
+		RwMatrix *camMat = RwFrameGetLTM(RwCameraGetFrame(RwCameraGetCurrentCamera())); //or curWorld
+
+		float randomDampInv2 = (1.0f - fRandomDamp) * 2.0f;
+
+		float move = 1.0f / 16.0f;
+		float randomMove = 1.0f / (16.0f * fRandomMoveDiv);
+
+		float vertMul = 0.5f;
+
+		float wind = CWeather::WindClipped * 0.4f + 0.2f;
+		float waveWind = CWeather::WindClipped * fWave2Ampl + 0.05f;
+
+		float waveA = (TWOPI / 16.0f)
+			* ((fNormalDirectionScalar1 * Abs(camMat->at.x + camMat->at.y) + fNormMult) * (CWeather::WindClipped * 0.4f + 0.2f));
+
+		float waveB = TWOPI / (16.0f * fWave2NormScale)
+			* ((fNormalDirectionScalar2 * Abs(camMat->at.y - camMat->at.x) + fNormMultB) * (CWeather::WindClipped * 0.2f + 0.1f));
+
+		CVector vA(1.0f, 0.0f, 0.0f);
+		CVector vB(0.0f, 1.0f, 0.0f);
+
+		for ( int32 i = 0; i < 17; i++ )
+		{
+			for ( int32 j = 0; j < 17; j++ )
+			{
+				wavyTexCoords->u = float(i) * move + TEXTURE_ADDV;
+				wavyTexCoords->v = float(j) * move + TEXTURE_ADDU;
+
+				RwRGBAAssign(wavyPreLight, &color);
+
+				if (i > 0 && i < 16 && j > 0 && j < 16)
+				{
+					wavyMorphVerts->x += CGeneral::GetRandomNumberInRange(-1.0f, 1.0f) * randomMove;
+					wavyMorphVerts->x *= fRandomDamp;
+					wavyMorphVerts->x += float(i) * randomDampInv2;
+
+					wavyMorphVerts->y += CGeneral::GetRandomNumberInRange(-1.0f, 1.0f) * randomMove;
+					wavyMorphVerts->y *= fRandomDamp;
+					wavyMorphVerts->y += float(j) * randomDampInv2;
+				}
+
+				float morphVertXHalf = (i == 16) ? 0.0f : vertMul * wavyMorphVerts->x;
+				float morphVertYHalf = (j == 16) ? 0.0f : vertMul * wavyMorphVerts->y;
+
+				float waveMulA = (morphVertYHalf + morphVertXHalf) * (TWOPI / 16.0f) + fAngle;
+				float waveMulB = (morphVertYHalf - morphVertXHalf) * (TWOPI / (16.0f * fWave2InvLength)) + fAngle;
+
+				wavyMorphVerts->z = wind * Sin(waveMulA) + waveWind * Sin(waveMulB);
+
+				vA.z = (waveA * Cos(waveMulA)) - (waveB * Cos(waveMulB));
+				vB.z = (waveA * Cos(waveMulA)) + (waveB * Cos(waveMulB));
+
+				CVector norm = CrossProduct(vA, vB);
+				norm.Normalise();
+
+				wavyMorphNormals->x = norm.x;
+				wavyMorphNormals->y = norm.y;
+				wavyMorphNormals->z = norm.z;
+
+				++wavyPreLight;
+				++wavyTexCoords;
+
+				++wavyMorphVerts;
+				++wavyMorphNormals;
+			}
+		}
+
+		RpGeometryUnlock(wavyGeometry);
+	}
+
+	float fCentreX = fX + (SMALL_SECTOR_SIZE / 2);
+	float fCentreY = fY + (SMALL_SECTOR_SIZE / 2);
+#endif
+	
+#ifdef PC_WATER
+	if ( WavesCalculatedThisFrame )
+#endif
+	{
+		if (bDontRender == false
+			&& m_nRenderWaterLayers != 2
+			&& m_nRenderWaterLayers != 4
+			&& m_nRenderWaterLayers != 6 )
+		{
+			RwV3d pos = { 0.0f, 0.0f, 0.0f };
+
+			pos.x = fX;
+			pos.y = fY;
+			pos.z = fZ;
+	
+			RwFrameTranslate(RpAtomicGetFrame(ms_pWavyAtomic), &pos, rwCOMBINEREPLACE);
 		
-		CBoat::FillBoatList();
+			RpAtomicRender(ms_pWavyAtomic);
+		}
+	}
+}
 		
-		ASSERT( ms_pWavyAtomic != NULL );
+int16
+_RoundValue(int32 v)
+{
+	int16 result = v;
+	
+	while ( result < 0 )  result += 16;
+	while ( result > 16 ) result -= 16;
+	
+	return result;
+}
 
-		RpGeometry *geometry = RpAtomicGetGeometry(ms_pWavyAtomic);
-		
-		ASSERT( geometry != NULL );
+void
+CWaterLevel::RenderWavyMask(float fX, float fY, float fZ,
+		float fSectorX, float fSectorY,
+#ifdef PC_WATER
+		float fCamPosX, float fCamPosY,
+		float fCamDirX, float fCamDirY, RwRGBA const&color)
+#else
+		int32 nCamDirX, int32 nCamDirY, RwRGBA const&color)
+#endif
+{
+#ifndef PC_WATER
+	bool bRender = true;
+	if (m_nRenderWaterLayers != 0 && m_nRenderWaterLayers != 2 && m_nRenderWaterLayers != 3)
+		bRender = false;
+#endif
+	CVector vecSectorPos(fX + (LARGE_SECTOR_SIZE/2), fY + (LARGE_SECTOR_SIZE/2), fZ + 2.0f);
 
-		RwRGBA      *wavyPreLights = RpGeometryGetPreLightColors(geometry);
-		RwTexCoords *wavyTexCoords = RpGeometryGetVertexTexCoords(geometry, rwTEXTURECOORDINATEINDEX0);
-		RwV3d       *wavyVertices  = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(geometry, 0));
-		
-		ASSERT( wavyPreLights != NULL );
-		ASSERT( wavyTexCoords != NULL );
-		ASSERT( wavyVertices  != NULL );
+	if ( COcclusion::IsAABoxOccluded(vecSectorPos, LARGE_SECTOR_SIZE, LARGE_SECTOR_SIZE, 4.0f) )
+		return;
 
-		RpGeometryLock(geometry, rpGEOMETRYLOCKVERTICES
-								| rpGEOMETRYLOCKPRELIGHT
-								| rpGEOMETRYLOCKTEXCOORDS);
-		
-		for ( int32 i = 0; i < 9; i++ )
+#ifndef PC_WATER
+	float fUOffset = fX - (MAX_LARGE_SECTORS * (int32)floorf(fX / MAX_LARGE_SECTORS));
+	float fVOffset = fY - (MAX_LARGE_SECTORS * (int32)floorf(fY / MAX_LARGE_SECTORS));
+
+	int32 nSecsX = (int32)((fX - fSectorX) / 2.0f);
+	int32 nSecsY = (int32)((fY - fSectorY) / 2.0f);
+#endif
+	
+	RpGeometry    *wavyGeometry  = RpAtomicGetGeometry(ms_pWavyAtomic);
+	RpMorphTarget *wavyMorph     = RpGeometryGetMorphTarget(wavyGeometry, 0);
+	RwV3d *wavyMorphVerts        = RpMorphTargetGetVertices(wavyMorph);
+	RwV3d *wavyMorphNormals      = RpMorphTargetGetVertexNormals(wavyMorph);
+
+	RpGeometry    *maskGeometry  = RpAtomicGetGeometry(ms_pMaskAtomic);
+	RwTexCoords   *maskTexCoords = RpGeometryGetVertexTexCoords(maskGeometry, rwTEXTURECOORDINATEINDEX0);
+	RwRGBA        *maskPreLight  = RpGeometryGetPreLightColors(maskGeometry);
+	RpMorphTarget *maskMorph     = RpGeometryGetMorphTarget(maskGeometry, 0);
+	RwV3d *maskMorphVerts        = RpMorphTargetGetVertices(maskMorph);
+	RwV3d *maskMorphNormals      = RpMorphTargetGetVertexNormals(maskMorph);
+
+	RpGeometryLock(maskGeometry, rpGEOMETRYLOCKVERTICES|rpGEOMETRYLOCKNORMALS|rpGEOMETRYLOCKPRELIGHT|rpGEOMETRYLOCKTEXCOORDS);
+	
+#ifndef PC_WATER
+	RpMaterial *maskMat = RpGeometryGetMaterial(maskGeometry, 0);
+	RpMatFXMaterialSetEnvMapFrame(maskMat, RwCameraGetFrame(RwCameraGetCurrentCamera()));
+	RpMatFXMaterialSetEnvMapCoefficient(maskMat, fEnvScale);
+	RpMatFXMaterialSetEnvMapFrameBufferAlpha(maskMat, TRUE);
+#endif
+	
+#ifndef PC_WATER
+	float fMinSparkZ = (CWeather::WindClipped * fWave2Ampl + 0.05f +
+		CWeather::WindClipped * 0.4f + 0.2) * (1.0f - 0.04f * CWeather::SunGlare);
+
+	int32 randval = CGeneral::GetRandomNumber();
+
+	float fUVStep = 0.125f;
+	float f27 = 2.0f;
+
+	float fMinU = (fUOffset / 16.0f) + _TEXTURE_MASK_ADDU;
+	float fMinV = (fVOffset / 16.0f) + _TEXTURE_MASK_ADDV;
+
+	float fAlphaMul = ((float)color.alpha * 0.4f) / 16.0f;
+
+	float fXOffset = 16.0f;
+	if (nCamDirX > 0)
+		fXOffset = 6.4f;
+	else if (nCamDirX < 0)
+		fXOffset = 25.6f;
+
+	float fYOffset = 16.0f;
+	if (nCamDirY > 0)
+		fYOffset = 6.4f;
+	else if (nCamDirY < 0)
+		fYOffset = 25.6f;
+
+	int16 nX = _RoundValue(nSecsX - 1);
+	int16 nY = _RoundValue(nSecsY - 1);
+#else
+	float fMinSparkZ = (fWave2Ampl * CWeather::WindClipped + 0.05f + 
+			0.4f * CWeather::WindClipped + 0.2) * (1.0f - 0.02f * CWeather::SunGlare);
+
+	int32 randval = CGeneral::GetRandomNumber() & 255;
+
+	int16 nX = _RoundValue((int32)((fX - fSectorX) * 0.5f) - 1);
+	int16 nY = _RoundValue((int32)((fY - fSectorY) * 0.5f) - 1);
+#endif
+	int16 idxX = nX;
+	
+	for ( int32 i = 0; i < 17; i++ )
+	{
+		int16 idxY = nY;
+
+		if ( ++idxX > 16 )
+				idxX -= 16;
+			
+		for ( int32 j = 0; j < 17; j++ )
 		{
-			for ( int32 j = 0; j < 9; j++ )
+			if ( ++idxY > 16 )
+				idxY -= 16;
+			
+			const int32 a = (0*16);
+			const int32 b = (1*16);
+			const int32 c = (33*16);
+			const int32 d = (34*16);
+			
+			int32 base = (i*33+j);
+			
+#ifndef  PC_WATER
+			maskTexCoords[base + a].u = fMinU + ((float)i * fUVStep);
+			maskTexCoords[base + a].v = fMinV + ((float)j * fUVStep);
+
+			maskTexCoords[base + b].u = maskTexCoords[base + a].u;
+			maskTexCoords[base + b].v = maskTexCoords[base + a].v + (16.0f * fUVStep);
+
+			maskTexCoords[base + c].u = maskTexCoords[base + a].u + (16.0f * fUVStep);
+			maskTexCoords[base + c].v = maskTexCoords[base + a].v;
+
+			maskTexCoords[base + d].u = maskTexCoords[base + a].u + (16.0f * fUVStep);
+			maskTexCoords[base + d].v = maskTexCoords[base + a].v + (16.0f * fUVStep);
+#else
+			maskTexCoords[base+a].v = float(j) / SMALL_SECTOR_SIZE + ((fCamPosY - fY) / 64);
+			maskTexCoords[base+c].v = maskTexCoords[base+a].v;
+			maskTexCoords[base+d].v = maskTexCoords[base+a].v + 0.5f;
+			maskTexCoords[base+b].v = maskTexCoords[base+d].v;
+			
+			maskTexCoords[base+a].u = float(i) / SMALL_SECTOR_SIZE + ((fCamPosX - fX) / 64);
+			maskTexCoords[base+b].u = maskTexCoords[base+a].u;
+			maskTexCoords[base+d].u = maskTexCoords[base+a].u + 0.5f;
+			maskTexCoords[base+c].u = maskTexCoords[base+d].u;
+#endif
+			
+			maskMorphVerts[base+a].x = (wavyMorphVerts[idxY + (17 * idxX)].x - (float)idxX * 2.0f) + (float(i) * 2.0f);
+			maskMorphVerts[base+b].x = maskMorphVerts[base+a].x;
+			maskMorphVerts[base+c].x = maskMorphVerts[base+a].x + SMALL_SECTOR_SIZE;
+			maskMorphVerts[base+d].x = maskMorphVerts[base+c].x;
+			
+			maskMorphVerts[base+a].y = (wavyMorphVerts[idxY + (17 * idxX)].y - (float)idxY * 2.0f) + (float(j) * 2.0f);
+			maskMorphVerts[base+c].y = maskMorphVerts[base+a].y;
+			maskMorphVerts[base+b].y = maskMorphVerts[base+a].y + SMALL_SECTOR_SIZE;
+			maskMorphVerts[base+d].y = maskMorphVerts[base+b].y;
+			
+			maskMorphVerts[base+a].z = wavyMorphVerts[idxY + (17 * idxX)].z;
+			maskMorphVerts[base+d].z = maskMorphVerts[base+a].z;
+			maskMorphVerts[base+c].z = maskMorphVerts[base+d].z;
+			maskMorphVerts[base+b].z = maskMorphVerts[base+c].z;
+			
+#ifndef PC_WATER
+			if (maskMorphVerts[base].z >= fMinSparkZ)
+#else
+			if ( maskMorphVerts[base].z > fMinSparkZ )
+#endif
 			{
-				wavyTexCoords[9*i+j].u = float(i) / 8 + TEXTURE_ADDV;
-				wavyTexCoords[9*i+j].v = float(j) / 8 + TEXTURE_ADDU;
-				RwRGBAAssign(&wavyPreLights[9*i+j], &color);
+				switch ( (i + j + randval) & 3 )
+				{
+					case 0:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+a].x,
+								fY + maskMorphVerts[base+a].y,
+								fZ + maskMorphVerts[base+a].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
+
+					case 1:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+c].x,
+								fY + maskMorphVerts[base+c].y,
+								fZ + maskMorphVerts[base+c].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
+
+					case 2:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+b].x,
+								fY + maskMorphVerts[base+b].y,
+								fZ + maskMorphVerts[base+b].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
 
-				wavyVertices[9*i+j].z = ( CWeather::Wind * 0.7f + 0.3f )
-										* ( Sin(float(i + j) * DEGTORAD(45.0f) + fAngle) )
-										+ ( CWeather::Wind * 0.2f * Sin(float(j - i) * PI + (2.0f * fAngle)) );
+					case 3:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+d].x,
+								fY + maskMorphVerts[base+d].y,
+								fZ + maskMorphVerts[base+d].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
+				}
 			}
+
+			maskMorphNormals[base+a].x = wavyMorphNormals[idxY + (17 * idxX)].x;
+			maskMorphNormals[base+a].y = wavyMorphNormals[idxY + (17 * idxX)].y;
+			maskMorphNormals[base+a].z = wavyMorphNormals[idxY + (17 * idxX)].z;
+			
+			maskMorphNormals[base+d].x = maskMorphNormals[base+a].x;
+			maskMorphNormals[base+d].y = maskMorphNormals[base+a].y;
+			maskMorphNormals[base+d].z = maskMorphNormals[base+a].z;
+			
+			maskMorphNormals[base+c].x = maskMorphNormals[base+d].x;
+			maskMorphNormals[base+c].y = maskMorphNormals[base+d].y;
+			maskMorphNormals[base+c].z = maskMorphNormals[base+d].z;
+			
+			maskMorphNormals[base+b].x = maskMorphNormals[base+c].x;
+			maskMorphNormals[base+b].y = maskMorphNormals[base+c].y;
+			maskMorphNormals[base+b].z = maskMorphNormals[base+c].z;
+	  
+			maskPreLight[base+a].red   = color.red;
+			maskPreLight[base+a].green = color.green;
+			maskPreLight[base+a].blue  = color.blue;
+			maskPreLight[base+a].alpha = color.alpha;
+			
+			maskPreLight[base+d].red   = maskPreLight[base+a].red;
+			maskPreLight[base+d].green = maskPreLight[base+a].green;
+			maskPreLight[base+d].blue  = maskPreLight[base+a].blue;
+			maskPreLight[base+d].alpha = maskPreLight[base+a].alpha;
+			
+			maskPreLight[base+c].red   = maskPreLight[base+d].red;
+			maskPreLight[base+c].green = maskPreLight[base+d].green;
+			maskPreLight[base+c].blue  = maskPreLight[base+d].blue;
+			maskPreLight[base+c].alpha = maskPreLight[base+d].alpha;
+			
+			maskPreLight[base+b].red   = maskPreLight[base+c].red;
+			maskPreLight[base+b].green = maskPreLight[base+c].green;
+			maskPreLight[base+b].blue  = maskPreLight[base+c].blue;
+			maskPreLight[base+b].alpha = maskPreLight[base+c].alpha;
+
+#ifndef PC_WATER
+			maskPreLight[base + a].alpha = Max(0, (int32)((float)color.alpha - (fAlphaMul * (Abs((float)i - fXOffset) + Abs((float)j - fYOffset)))));
+			maskPreLight[base + b].alpha = Max(0, (int32)((float)color.alpha - (fAlphaMul * (Abs((float)i - fXOffset) + Abs(16.0f + (float)j - fYOffset)))));
+			maskPreLight[base + c].alpha = Max(0, (int32)((float)color.alpha - (fAlphaMul * (Abs(16.0f + (float)i - fXOffset) + Abs((float)j - fYOffset)))));
+			maskPreLight[base + d].alpha = Max(0, (int32)((float)color.alpha - (fAlphaMul * (Abs(16.0f + (float)i - fXOffset) + Abs(16.0f + (float)j - fYOffset)))));
+#endif
 		}
-		
-		RpGeometryUnlock(geometry);
 	}
 	
-	static CBoat *apBoatList[4] = { NULL };
+	RpGeometryUnlock(maskGeometry);
+
+#ifndef PC_WATER
+	{
+		RwV3d pos = { 0.0f, 0.0f, 0.0f };
+
+		pos.x = fX;
+		pos.y = fY;
+		pos.z = fZ + 0.05f;
+
+		RwFrameTranslate(RpAtomicGetFrame(ms_pMaskAtomic), &pos, rwCOMBINEREPLACE);
+
+		if (bRender)
+		{
+#ifdef PS2
+			RpSkyTexCacheFlush();
+#endif
+			RpAtomicRender(ms_pMaskAtomic);
+		}
+	}
+#endif
+}
+
+#ifdef PC_WATER
+void
+CWaterLevel::PreCalcWaterGeometry(void)
+{
+	if ( !RequireWavySector )
+	{
+		WavesCalculatedThisFrame = false;
+		MaskCalculatedThisFrame = false;
+		return;
+	}
+	
+	RequireWavySector = false;
+	WavesCalculatedThisFrame = true;
 	
-	if ( apGeomArray[0]
-		&& nGeomUsed < MAX_BOAT_WAKES
-		&& CBoat::IsSectorAffectedByWake(
-			CVector2D(fX + (SMALL_SECTOR_SIZE / 2), fY + (SMALL_SECTOR_SIZE / 2)),
-			SMALL_SECTOR_SIZE / 2,
-			apBoatList) )
+	RwRGBA color;
+	
+	color.red   = CTimeCycle::GetWaterRed();
+	color.green = CTimeCycle::GetWaterGreen();
+	color.blue  = CTimeCycle::GetWaterBlue();
+	color.alpha = CTimeCycle::GetWaterAlpha();
+	
+	PreCalcWavySector(color);
+	
+	if ( CCullZones::WaterFudge() )
 	{
-		float fWakeColor = fAdd1 - Max(255.0f - float(color.blue + color.red + color.green) / 3, fAdd2);
-		
-		RpGeometry *wavyGeometry = RpAtomicGetGeometry(ms_pWavyAtomic);	
-		RpGeometry *geom  = apGeomArray[nGeomUsed++];
-		
-		ASSERT( wavyGeometry != NULL );
-		ASSERT( geom != NULL );
-		
-		RpAtomic *atomic = RpAtomicCreate();
-		ASSERT( atomic != NULL );
-		
-		RpAtomicSetGeometry(atomic, geom, 0);
-		
-		RwFrame *frame = RwFrameCreate();
-		ASSERT( frame != NULL );
-		
-		RwMatrixCopy(RwFrameGetMatrix(frame), RwFrameGetMatrix(RpAtomicGetFrame(ms_pWavyAtomic)));
-		RpAtomicSetFrame(atomic, frame);
+		MaskCalculatedThisFrame = false;
+		return;
+	}
+	
+	CVector CamFwdDir = TheCamera.GetForward();
+	CamFwdDir.z = 0.0f;
+	CamFwdDir.Normalise();
+	
+	float fCamX = TheCamera.GetPosition().x - SMALL_SECTOR_SIZE;
+	float fCamY = TheCamera.GetPosition().y - SMALL_SECTOR_SIZE;
+	
+	//1.4144272f; 1.4144f;
+	float signX = CamFwdDir.x * 1.4144272f;
+	float signY = CamFwdDir.y * 1.4144272f;
+	
+	signX = clamp(signX, -1.0f, 1.0f);
+	fCamX += 0.4f * signX * float(SMALL_SECTOR_SIZE * 2.0f);
+
+	signY = clamp(signY, -1.0f, 1.0f);
+	fCamY += 0.4f * signY * float(SMALL_SECTOR_SIZE * 2.0f);
+	
+	int32 nBlock;
+	
+	int32 BlockX = WATER_TO_SMALL_SECTOR_X(fCamX + WATER_X_OFFSET) + 1;
+	int32 BlockY = WATER_TO_SMALL_SECTOR_Y(fCamY                 ) + 1;
+	
+	ASSERT( BlockX >= 0 && BlockX < MAX_SMALL_SECTORS );
+	ASSERT( BlockY >= 0 && BlockY < MAX_SMALL_SECTORS );
+	
+	if ( _IsColideWithBlock(BlockX, BlockY, nBlock) )
+	{
+		float fMaskX = floorf(fCamX / 2.0f) * 2.0f;
+		float fMaskY = floorf(fCamY / 2.0f) * 2.0f;
+
+		float fSectorX = WATER_FROM_SMALL_SECTOR_X(BlockX) - WATER_X_OFFSET;
+		float fSectorY = WATER_FROM_SMALL_SECTOR_Y(BlockY);
 		
-		RwTexCoords *geomTexCoords  = RpGeometryGetVertexTexCoords(geom, rwTEXTURECOORDINATEINDEX0);
-		RwTexCoords *wavyTexCoord   = RpGeometryGetVertexTexCoords(wavyGeometry, rwTEXTURECOORDINATEINDEX0);
-		RwRGBA *geomPreLights       = RpGeometryGetPreLightColors(geom);
-		RwV3d  *geomVertices        = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(geom, 0));
-		RwV3d  *wavyVertices        = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(wavyGeometry, 0));
+		if ( PreCalcWavyMask( fMaskX, fMaskY, ms_aWaterZs[nBlock],
+				fSectorX, fSectorY, fCamX, fCamY, CamFwdDir.x, CamFwdDir.y, color ) )
+        {
+			PreCalculatedMaskPosn.x = fMaskX;
+			PreCalculatedMaskPosn.y = fMaskY;
+			PreCalculatedMaskPosn.z = ms_aWaterZs[nBlock] + 0.05f;
+			
+			MaskCalculatedThisFrame = true;
+		}
+		else
+			MaskCalculatedThisFrame = false;
+	}
+	else
+		MaskCalculatedThisFrame = false;
+}
+
+bool
+CWaterLevel::PreCalcWavySector(RwRGBA const &color)
+{	
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
+	
+	RpGeometry *wavyGeometry   = RpAtomicGetGeometry(ms_pWavyAtomic);
+
+	RwTexCoords *wavyTexCoords = RpGeometryGetVertexTexCoords(wavyGeometry, rwTEXTURECOORDINATEINDEX0);
+	RpMorphTarget *wavyMorph   = RpGeometryGetMorphTarget(wavyGeometry, 0);
+	
+	RwRGBA *wavyPreLight       = RpGeometryGetPreLightColors(wavyGeometry);
+	RwV3d *wavyMorphVerts      = RpMorphTargetGetVertices(wavyMorph);
+	RwV3d *wavyMorphNormals    = RpMorphTargetGetVertexNormals(wavyMorph);
+	
+	if ( !m_bRenderSeaBed )
+		RpGeometryLock(wavyGeometry, rpGEOMETRYLOCKVERTICES
+									|rpGEOMETRYLOCKNORMALS
+									|rpGEOMETRYLOCKPRELIGHT
+									|rpGEOMETRYLOCKTEXCOORDS);
+	
+	CVector camPosUp = TheCamera.GetForward();
 		
-		ASSERT( geomTexCoords != NULL );
-		ASSERT( wavyTexCoord  != NULL );
-		ASSERT( geomPreLights != NULL );
-		ASSERT( geomVertices  != NULL );
-		ASSERT( wavyVertices  != NULL );
+	float randomDampInv2 = (1.0f - fRandomDamp) * 2.0f;
+	
+	float randomMove = 1.0f / (16.0f * fRandomMoveDiv);
+	
+	float wind     = CWeather::WindClipped * 0.4f + 0.2f;
+	float waveWind = CWeather::WindClipped * fWave2Ampl + 0.05f;
 
-		RpGeometryLock(geom, rpGEOMETRYLOCKVERTICES | rpGEOMETRYLOCKPRELIGHT | rpGEOMETRYLOCKTEXCOORDS);
+	float waveA = (TWOPI / 16.0f)
+		* ((CWeather::WindClipped * 0.4f + 0.2f) * (fNormalDirectionScalar1 * Abs(camPosUp.x + camPosUp.y) + fNormMult));
 		
-		for ( int32 i = 0; i < 9; i++ )
+	float waveB = TWOPI / (16.0f * fWave2NormScale)
+		* ((CWeather::WindClipped * 0.2f + 0.1f) * (fNormalDirectionScalar2 * Abs(camPosUp.y - camPosUp.x) + fNormMultB));
+
+	
+	CVector vA(1.0f, 0.0f, 0.0f);
+	CVector vB(0.0f, 1.0f, 0.0f);
+			
+	for ( int32 i = 0; i < 17; i++ )
+	{
+		for ( int32 j = 0; j < 17; j++ )
 		{
-			for ( int32 j = 0; j < 9; j++ )
+			wavyTexCoords->u = (float(i) / 16.0f) + TEXTURE_ADDV;
+			wavyTexCoords->v = (float(j) / 16.0f) + TEXTURE_ADDU;
+
+			RwRGBAAssign(wavyPreLight, &color);
+			
+			if ( i > 0 && i < 16 && j > 0 && j < 16 )
 			{
-				geomTexCoords[9*i+j] = wavyTexCoord[9*i+j];
+				wavyMorphVerts->x += CGeneral::GetRandomNumberInRange(-1.0f, 1.0f) * randomMove;
+				wavyMorphVerts->x *= fRandomDamp;
+				wavyMorphVerts->x += float(i) * randomDampInv2;
+				
+				wavyMorphVerts->y += CGeneral::GetRandomNumberInRange(-1.0f, 1.0f) * randomMove;
+				wavyMorphVerts->y *= fRandomDamp;
+				wavyMorphVerts->y += float(j) * randomDampInv2;
+			}
+			
+			float morphVertXHalf = ( i == 16 ) ? 0.0f : 0.5f * wavyMorphVerts->x;
+			float morphVertYHalf = ( j == 16 ) ? 0.0f : 0.5f * wavyMorphVerts->y;
+			
+			float waveMulA = (morphVertYHalf + morphVertXHalf) * (TWOPI / 16.0f) + fAngle;	  
+			float waveMulB = (morphVertYHalf - morphVertXHalf) * (TWOPI / (16.0f * fWave2InvLength)) + fAngle;		
+	
+			wavyMorphVerts->z = wind * Sin(waveMulA) + waveWind * Sin(waveMulB);
+			
+			vA.z = (waveA * Cos(waveMulA)) - (waveB * Cos(waveMulB));
+			vB.z = (waveA * Cos(waveMulA)) + (waveB * Cos(waveMulB));
 
-				float fVertexX = (float)i * 4.0f + fX;
-				float fVertexY = (float)j * 4.0f + fY;
+			CVector norm = CrossProduct(vA, vB);
+			norm.Normalise();
 
-				float fDistMult = 0.0f;
-		
-				for ( int32 k = 0; k < 4; k++ )
-				{
-					if ( apBoatList[k] != NULL )
-						fDistMult += CBoat::IsVertexAffectedByWake(CVector(fVertexX, fVertexY, 0.0f), apBoatList[k]);
-				}
-				
-				if ( fDistMult > 0.0f )
+			wavyMorphNormals->x = norm.x;
+			wavyMorphNormals->y = norm.y;
+			wavyMorphNormals->z = norm.z;
+
+			++wavyPreLight;
+			++wavyTexCoords;
+
+			++wavyMorphVerts;
+			++wavyMorphNormals;
+		}
+	}
+
+	RpGeometryUnlock(wavyGeometry);
+	
+	return true;
+}
+
+bool
+CWaterLevel::PreCalcWavyMask(float fX, float fY, float fZ,
+		float fSectorX, float fSectorY,
+		float fCamPosX, float fCamPosY,
+		float fCamDirX, float fCamDirY,
+		RwRGBA const&color)
+{
+	CVector vecSectorPos(fX + (MAX_LARGE_SECTORS/2), fY + (MAX_LARGE_SECTORS/2), fZ + 2.0f);
+	
+	if ( COcclusion::IsAABoxOccluded(vecSectorPos, MAX_LARGE_SECTORS, MAX_LARGE_SECTORS, 4.0f) )
+		return false;
+	
+	floorf(fX / MAX_LARGE_SECTORS);
+	floorf(fY / MAX_LARGE_SECTORS);
+	
+	RpGeometry    *wavyGeometry  = RpAtomicGetGeometry(ms_pWavyAtomic);
+	RpMorphTarget *wavyMorph     = RpGeometryGetMorphTarget(wavyGeometry, 0);
+	RwV3d *wavyMorphVerts        = RpMorphTargetGetVertices(wavyMorph);
+	RwV3d *wavyMorphNormals      = RpMorphTargetGetVertexNormals(wavyMorph);
+	
+	RpGeometry    *maskGeometry  = RpAtomicGetGeometry(ms_pMaskAtomic);
+	RwTexCoords   *maskTexCoords = RpGeometryGetVertexTexCoords(maskGeometry, rwTEXTURECOORDINATEINDEX0);
+	RwRGBA        *maskPreLight  = RpGeometryGetPreLightColors(maskGeometry);
+	RpMorphTarget *maskMorph     = RpGeometryGetMorphTarget(maskGeometry, 0);
+	RwV3d *maskMorphVerts        = RpMorphTargetGetVertices(maskMorph);
+	RwV3d *maskMorphNormals      = RpMorphTargetGetVertexNormals(maskMorph);
+
+	if ( !m_bRenderSeaBed )
+		RpGeometryLock(maskGeometry, rpGEOMETRYLOCKVERTICES | rpGEOMETRYLOCKNORMALS | rpGEOMETRYLOCKPRELIGHT | rpGEOMETRYLOCKTEXCOORDS);
+	
+	
+	float fMinSparkZ = (fWave2Ampl * CWeather::WindClipped + 0.05f + 
+			0.4f * CWeather::WindClipped + 0.2) * (1.0f - 0.02f * CWeather::SunGlare);
+	
+	int32 randval = CGeneral::GetRandomNumber() & 255;
+
+	int16 nX = _RoundValue((int32)((fX - fSectorX) * 0.5f) - 1);
+	int16 nY = _RoundValue((int32)((fY - fSectorY) * 0.5f) - 1);
+	
+	int16 idxX = nX;
+
+	for ( int32 i = 0; i < 17; i++ )
+	{		
+		int16 idxY = nY;
+
+		if ( ++idxX > 16 )
+				idxX -= 16;
+			
+		for ( int32 j = 0; j < 17; j++ )
+		{
+			if ( ++idxY > 16 )
+				idxY -= 16;
+			
+			const int32 a = (0*16);
+			const int32 b = (1*16);
+			const int32 c = (33*16);
+			const int32 d = (34*16);
+			
+			int32 base = (i*33+j);
+			
+			maskTexCoords[base+a].v = float(j) / 32 + ((fCamPosY - fY) / 64);
+			maskTexCoords[base+c].v = maskTexCoords[base+a].v;
+			maskTexCoords[base+d].v = maskTexCoords[base+a].v + 0.5f;
+			maskTexCoords[base+b].v = maskTexCoords[base+d].v;
+			
+			maskTexCoords[base+a].u = float(i) / 32 + ((fCamPosX - fX) / 64);
+			maskTexCoords[base+b].u = maskTexCoords[base+a].u;
+			maskTexCoords[base+d].u = maskTexCoords[base+a].u + 0.5f;
+			maskTexCoords[base+c].u = maskTexCoords[base+d].u;
+			
+			maskMorphVerts[base+a].x = (wavyMorphVerts[idxY + (17 * idxX)].x - (float)idxX * 2.0f) + (float(i) * 2.0f);
+			maskMorphVerts[base+b].x = maskMorphVerts[base+a].x;
+			maskMorphVerts[base+c].x = maskMorphVerts[base+a].x + SMALL_SECTOR_SIZE;
+			maskMorphVerts[base+d].x = maskMorphVerts[base+c].x;
+			
+			maskMorphVerts[base+a].y = (wavyMorphVerts[idxY + (17 * idxX)].y - (float)idxY * 2.0f) + (float(j) * 2.0f);
+			maskMorphVerts[base+c].y = maskMorphVerts[base+a].y;
+			maskMorphVerts[base+b].y = maskMorphVerts[base+a].y + SMALL_SECTOR_SIZE;
+			maskMorphVerts[base+d].y = maskMorphVerts[base+b].y;
+			
+			maskMorphVerts[base+a].z = wavyMorphVerts[idxY + (17 * idxX)].z;
+			maskMorphVerts[base+d].z = maskMorphVerts[base+a].z;
+			maskMorphVerts[base+c].z = maskMorphVerts[base+d].z;
+			maskMorphVerts[base+b].z = maskMorphVerts[base+c].z;
+			
+			if ( maskMorphVerts[base].z > fMinSparkZ )
+			{
+				switch ( (i + j + randval) & 3 )
 				{
-					RwRGBA wakeColor;
-					
-					RwRGBAAssign(&wakeColor, &color);
+					case 0:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+a].x,
+								fY + maskMorphVerts[base+a].y,
+								fZ + maskMorphVerts[base+a].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
 
-					wakeColor.red   = Min(color.red   + int32(fWakeColor * fRedMult   * fDistMult), 255);
-					wakeColor.green = Min(color.green + int32(fWakeColor * fGreenMult * fDistMult), 255);
-					wakeColor.blue  = Min(color.blue  + int32(fWakeColor * fBlueMult  * fDistMult), 255);
-					
-					RwRGBAAssign(&geomPreLights[9*i+j], &wakeColor);
+					case 1:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+c].x,
+								fY + maskMorphVerts[base+c].y,
+								fZ + maskMorphVerts[base+c].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
 
+					case 2:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+b].x,
+								fY + maskMorphVerts[base+b].y,
+								fZ + maskMorphVerts[base+b].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
+
+					case 3:
+						{
+							CVector vecPos
+							(
+								fX + maskMorphVerts[base+d].x,
+								fY + maskMorphVerts[base+d].y,
+								fZ + maskMorphVerts[base+d].z + 0.12f
+							);
+
+							vecPos -= 0.05f * TheCamera.GetForward();
+							
+							CParticle::AddParticle(PARTICLE_WATER_SPARK,
+								vecPos,
+								CVector(0.0f, 0.0f, 0.0f),
+								nil,
+								0.0f,
+								15,
+								CGeneral::GetRandomNumberInRange(-90, 90),
+								0,
+								0);
+						}
+						break;
 				}
-				else
-					RwRGBAAssign(&geomPreLights[9*i+j], &color);
-				
-				
-				geomVertices[9*i+j].z = wavyVertices[9*i+j].z;
 			}
+
+			maskMorphNormals[base+a].x = wavyMorphNormals[idxY + (17 * idxX)].x;
+			maskMorphNormals[base+a].y = wavyMorphNormals[idxY + (17 * idxX)].y;
+			maskMorphNormals[base+a].z = wavyMorphNormals[idxY + (17 * idxX)].z;
+			
+			maskMorphNormals[base+d].x = maskMorphNormals[base+a].x;
+			maskMorphNormals[base+d].y = maskMorphNormals[base+a].y;
+			maskMorphNormals[base+d].z = maskMorphNormals[base+a].z;
+			
+			maskMorphNormals[base+c].x = maskMorphNormals[base+d].x;
+			maskMorphNormals[base+c].y = maskMorphNormals[base+d].y;
+			maskMorphNormals[base+c].z = maskMorphNormals[base+d].z;
+			
+			maskMorphNormals[base+b].x = maskMorphNormals[base+c].x;
+			maskMorphNormals[base+b].y = maskMorphNormals[base+c].y;
+			maskMorphNormals[base+b].z = maskMorphNormals[base+c].z;
+	  
+			maskPreLight[base+a].red   = color.red;
+			maskPreLight[base+a].green = color.green;
+			maskPreLight[base+a].blue  = color.blue;
+			maskPreLight[base+a].alpha = color.alpha;
+			
+			maskPreLight[base+d].red   = maskPreLight[base+a].red;
+			maskPreLight[base+d].green = maskPreLight[base+a].green;
+			maskPreLight[base+d].blue  = maskPreLight[base+a].blue;
+			maskPreLight[base+d].alpha = maskPreLight[base+a].alpha;
+			
+			maskPreLight[base+c].red   = maskPreLight[base+d].red;
+			maskPreLight[base+c].green = maskPreLight[base+d].green;
+			maskPreLight[base+c].blue  = maskPreLight[base+d].blue;
+			maskPreLight[base+c].alpha = maskPreLight[base+d].alpha;
+			
+			maskPreLight[base+b].red   = maskPreLight[base+c].red;
+			maskPreLight[base+b].green = maskPreLight[base+c].green;
+			maskPreLight[base+b].blue  = maskPreLight[base+c].blue;
+			maskPreLight[base+b].alpha = maskPreLight[base+c].alpha;
 		}
+	}
+	
+	RpGeometryUnlock(maskGeometry);
+	return true;
+}
+#endif
+
+void
+CWaterLevel::RenderBoatWakes(void)
+{
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)gpWaterWakeRaster);
+#ifndef PC_WATER
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+#endif
+
+#ifdef _XBOX
+	// TODO save and restore rwRENDERSTATESRCBLEND rwRENDERSTATEDESTBLEND
+#endif
+
+	CBoat::FillBoatList();
+	
+	float fWakeZ = 5.97f;
+	float fWakeLifeTimeMult = 0.01f / CBoat::WAKE_LIFETIME;
+	
+	for ( int32 idx = 0; idx < ARRAY_SIZE(CBoat::apFrameWakeGeneratingBoats); idx++ )
+	{
+		CBoat *pBoat = CBoat::apFrameWakeGeneratingBoats[idx];
+
+		if ( pBoat == nil )
+			break;
+
+		CVector2D vecDistA(pBoat->GetForward().x, pBoat->GetForward().y);
+
+
+		float fSize = pBoat->GetColModel()->boundingBox.max.z
+				* 0.65f;
 		
-		RpGeometryUnlock(geom);
+		if ( pBoat->GetModelIndex() == MI_SKIMMER)
+			fSize *= 0.4f;
 		
+		float fAplhaA = 255.0f;
+		float fSizeA = fSize;
+		float fAplhaB;
+		float fSizeB;
 		
-		RwV3d pos = {0.0f, 0.0f, 0.0f};
+		for ( int32 wake = 1; wake < pBoat->m_nNumWakePoints; wake++ )
+		{
+			bool bRender = true;
+			
+			float fTimeleft = CBoat::WAKE_LIFETIME - pBoat->m_afWakePointLifeTime[wake];
 
-		pos.x = fX;
-		pos.z = fZ;
-		pos.y = fY;
+			float fWakeSizeB = ((float)wake * 0.19f) + fSize - fWakeLifeTimeMult * Max(fTimeleft, 0.0f);
+			
+			fSizeB = fWakeSizeB / CBoat::MIN_WAKE_INTERVAL;
+			if ( fSizeB < 0.0f )
+				fSizeB = 1.0f;
+			
+			if ( wake == pBoat->m_nNumWakePoints - 1 )
+			{
+				// set alpha to 0 if it's last point
+				fAplhaB = 0.0f;
+			}
+			else
+			{
+				// clip (-100, 500), less lifetime - less val
+				float val = 500.0f - (CBoat::WAKE_LIFETIME - pBoat->m_afWakePointLifeTime[wake])
+						* 600.0f / CBoat::WAKE_LIFETIME;
+						
+				fAplhaB = clamp(val, 0.0f, 255.0f);
+			}
 
-		RwFrameTranslate(RpAtomicGetFrame(atomic), &pos, rwCOMBINEREPLACE);
+			CVector2D vecDistB = pBoat->m_avec2dWakePoints[wake - 1] - pBoat->m_avec2dWakePoints[wake];
 
-		RpAtomicRender(atomic);
-		
-		RpAtomicDestroy(atomic);
-		RwFrameDestroy(frame);
+			float fScal = vecDistB.MagnitudeSqr();
+			
+			// normalize if distance between points is greater than 3
+
+			if ( fScal > SQR(3.0f) )
+			{				
+				float fNorm = 1.0f / sqrt(fScal);
+				
+				vecDistB.x *= fNorm;
+				vecDistB.y *= fNorm;
+				
+				// disable render if distance between points too big
+				
+				if ( sqrt(fScal) > 13.0f )
+					bRender = false;
+			}
+			
+			CVector2D vecAA
+			(
+				pBoat->m_avec2dWakePoints[wake - 1].x - (fSizeA * vecDistA.y),
+				pBoat->m_avec2dWakePoints[wake - 1].y + (fSizeA * vecDistA.x)
+			);
+			CVector2D vecAB
+			(
+				pBoat->m_avec2dWakePoints[wake - 1].x + (fSizeA * vecDistA.y),
+				pBoat->m_avec2dWakePoints[wake - 1].y - (fSizeA * vecDistA.x)
+			);
+			CVector2D vecBA
+			(
+				pBoat->m_avec2dWakePoints[wake].x     + (fSizeB * vecDistB.y),
+				pBoat->m_avec2dWakePoints[wake].y     - (fSizeB * vecDistB.x)
+			);                                                                            
+			CVector2D vecBB                         
+			(                                       
+				pBoat->m_avec2dWakePoints[wake].x     - (fSizeB * vecDistB.y),
+				pBoat->m_avec2dWakePoints[wake].y     + (fSizeB * vecDistB.x)
+			);
+			
+			if ( bRender )
+				RenderWakeSegment(vecAA, vecAB, vecBA, vecBB, fSizeA, fSizeB, fAplhaA, fAplhaB, fWakeZ);
+			
+			vecDistA = vecDistB;
+			fSizeA = fSizeB;
+			
+			fAplhaB = fAplhaA;
+		}
 	}
-	else
+	
+	RenderAndEmptyRenderBuffer();
+}
+
+inline float
+_GetWindedWave(float fX, float fY)
+{
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);	
+	float x = WATER_HUGE_X(fX + WATER_X_OFFSET);
+	float y = WATER_HUGE_Y(fY);
+	
+	float fWindFactor (CWeather::WindClipped * 0.4f + 0.2f);
+	float fWave = Sin(( (x - floorf(x)) + (y - floorf(y)) ) * TWOPI + fAngle);
+
+	return fWindFactor * fWave;
+}
+
+void
+CWaterLevel::RenderWakeSegment(CVector2D &vecA, CVector2D &vecB, CVector2D &vecC, CVector2D &vecD,
+		float &fSizeA, float &fSizeB, 
+		float &fAlphaA, float &fAlphaB, 
+		float &fWakeZ)
+{
+	for ( int32 i = 0; i < 4; i++ )
 	{
-		RwV3d pos = { 0.0f, 0.0f, 0.0f };
+		if ( TempBufferIndicesStored >= TEMPBUFFERINDEXSIZE-6 || TempBufferVerticesStored >= TEMPBUFFERVERTSIZE-4 )
+			RenderAndEmptyRenderBuffer();
+		
+		float fCurStep = (float)i       / 4;
+		float fNxtStep = (float)(i + 1) / 4;
+		
+		float fLeftCurStep = 1.0f - fCurStep;
+		float fLeftNxtStep = 1.0f - fNxtStep;
 
-		pos.x = fX;
-		pos.y = fY;
-		pos.z = fZ;
+		uint8 AlphaA = (uint32)(fAlphaA * aAlphaFade[i]    );
+		uint8 AlphaB = (uint32)(fAlphaA * aAlphaFade[i + 1]);
+		uint8 AlphaC = (uint32)(fAlphaB * aAlphaFade[i + 1]);
+		uint8 AlphaD = (uint32)(fAlphaB * aAlphaFade[i]    );
+
+		CVector2D PosA = vecB*fCurStep + vecA*fLeftCurStep;
+		CVector2D PosB = vecB*fNxtStep + vecA*fLeftNxtStep;
+		CVector2D PosC = vecC*fNxtStep + vecD*fLeftNxtStep;
+		CVector2D PosD = vecC*fCurStep + vecD*fLeftCurStep;
+
+		float fUA = (PosA.x / 4) + _TEXTURE_WAKE_ADDU;
+		float fVA = (PosA.y / 4) + _TEXTURE_WAKE_ADDV;
+
+		float fUB = (PosB.x / 4) + _TEXTURE_WAKE_ADDU;
+		float fVB = (PosB.y / 4) + _TEXTURE_WAKE_ADDV;
+
+		float fUC = (PosC.x / 4) + _TEXTURE_WAKE_ADDU;
+		float fVC = (PosC.y / 4) + _TEXTURE_WAKE_ADDV;
+
+		float fUD = (PosD.x / 4) + _TEXTURE_WAKE_ADDU;
+		float fVD = (PosD.y / 4) + _TEXTURE_WAKE_ADDV;
 		
-		ASSERT( ms_pWavyAtomic != NULL );
+#define MIN4(a, b, c, d) (Min((a), Min((b), Min((c), (d)))))
+		float fMinU = floorf(MIN4(fUA, fUB, fUC, fUD));
+		float fMinV = floorf(MIN4(fVA, fVB, fVC, fVD));
+#undef MIN4
+
+		float fZA = _GetWindedWave(PosA.x, PosA.y) + fWakeZ;
+		float fZB = _GetWindedWave(PosB.x, PosB.y) + fWakeZ;
+		float fZC = _GetWindedWave(PosC.x, PosC.y) + fWakeZ;
+		float fZD = _GetWindedWave(PosD.x, PosD.y) + fWakeZ;
+	
+		int32 vidx = TempBufferVerticesStored;
+	
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], PosA.x, PosA.y, fZA);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], fUA - fMinU);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], fVA - fMinV);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], 255, 255, 255, AlphaA);
+
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], PosB.x, PosB.y, fZB);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], fUB - fMinU);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], fVB - fMinV);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 1], 255, 255, 255, AlphaB);
+
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], PosC.x, PosC.y, fZC);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], fUC - fMinU);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], fVC - fMinV);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 2], 255, 255, 255, AlphaC);
+
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], PosD.x, PosD.y, fZD);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], fUD - fMinU);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], fVD - fMinV);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 3], 255, 255, 255, AlphaD);
 		
-		RwFrameTranslate(RpAtomicGetFrame(ms_pWavyAtomic), &pos, rwCOMBINEREPLACE);
+		int32 iidx = TempBufferIndicesStored;
+	
+		TempBufferRenderIndexList[iidx + 0] = TempBufferVerticesStored + 0;
+		TempBufferRenderIndexList[iidx + 1] = TempBufferVerticesStored + 2;
+		TempBufferRenderIndexList[iidx + 2] = TempBufferVerticesStored + 1;
+		TempBufferRenderIndexList[iidx + 3] = TempBufferVerticesStored + 0;
+		TempBufferRenderIndexList[iidx + 4] = TempBufferVerticesStored + 3;
+		TempBufferRenderIndexList[iidx + 5] = TempBufferVerticesStored + 2;
 		
-		RpAtomicRender(ms_pWavyAtomic);
+		TempBufferVerticesStored += 4;
+	
+		TempBufferIndicesStored += 6;
 	}
 }
 
+void
+CWaterLevel::RenderOneSlopedUnderWaterPoly(float fX, float fY, float fZ, RwRGBA const&color)
+{
+	CVector2D camPos(TheCamera.GetPosition().x, TheCamera.GetPosition().y);
+	
+	float fDistA = (CVector2D(fX, fY) - camPos).Magnitude()                                       + -140.0f;
+	float fDistB = (CVector2D(fX, fY + HUGE_SECTOR_SIZE) - camPos).Magnitude()                    + -140.0f;
+	float fDistC = (CVector2D(fX + HUGE_SECTOR_SIZE, fY + HUGE_SECTOR_SIZE) - camPos).Magnitude() + -140.0f;
+	float fDistD = (CVector2D(fX + HUGE_SECTOR_SIZE, fY) - camPos).Magnitude()                    + -140.0f;
+	
+#ifndef PC_WATER
+#define CALCSEABED(v, d) \
+		{ \
+			if ( d < 0.0f ) \
+				v = 0.1f + fSeaBedZ; \
+			else if ( d > 240.0f ) \
+				v = 0.1f; \
+			else \
+				v = 0.1f + ((fSeaBedZ * (240.0f - d)) / 240.0f); \
+		}
+#else
+	#define CALCSEABED(v, d)	\
+		{	\
+		v = 0.1f;	\
+		if ( d < 0.0f )	\
+			v += fSeaBedZ;	\
+		else if ( d <= 240.0f )	\
+			v += (fSeaBedZ / 240.0f) * (240.0f - d);	\
+		}
+#endif
+	float fSeaBedA, fSeaBedB, fSeaBedC, fSeaBedD;
+	
+	CALCSEABED(fSeaBedA, fDistA);
+	CALCSEABED(fSeaBedB, fDistB);
+	CALCSEABED(fSeaBedC, fDistC);
+	CALCSEABED(fSeaBedD, fDistD);
+	
+	#undef CALCSEABED
+	
+	if ( TempBufferIndicesStored >= TEMPBUFFERINDEXSIZE-6 || TempBufferVerticesStored >= TEMPBUFFERVERTSIZE-4 )
+		RenderAndEmptyRenderBuffer();
+	
+	int32 vidx = TempBufferVerticesStored;
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset - fSeaBedA);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], 0.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], 0.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, 255);
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + HUGE_SECTOR_SIZE, fZ - _fWaterZOffset - fSeaBedB);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], 0.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], 4.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue, 255);
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + HUGE_SECTOR_SIZE, fY + HUGE_SECTOR_SIZE, fZ - _fWaterZOffset - fSeaBedC);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], 4.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], 4.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue, 255);
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + HUGE_SECTOR_SIZE, fY, fZ - _fWaterZOffset - fSeaBedD);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], 4.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], 0.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue, 255);
+	
+	int32 iidx = TempBufferIndicesStored;
+
+	TempBufferRenderIndexList[iidx + 0] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[iidx + 1] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[iidx + 2] = TempBufferVerticesStored + 1;
+	TempBufferRenderIndexList[iidx + 3] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[iidx + 4] = TempBufferVerticesStored + 3;
+	TempBufferRenderIndexList[iidx + 5] = TempBufferVerticesStored + 2;
+	
+	TempBufferVerticesStored += 4;
+
+	TempBufferIndicesStored += 6;
+}
+
+void
+CWaterLevel::RenderOneFlatSmallWaterPolyBlended(float fX, float fY, float fZ, float fCamX, float fCamY,
+		RwRGBA const &color, RwRGBA const &colorTrans,
+		float fDrawDist)
+{
+	if ( TempBufferIndicesStored >= TEMPBUFFERINDEXSIZE-6 || TempBufferVerticesStored >= TEMPBUFFERVERTSIZE-4 )
+		RenderAndEmptyRenderBuffer();
+	
+	int32 vidx = TempBufferVerticesStored;
+	
+	float fBlendDrawDist = fDrawDist + fStartBlendDistanceAdd;
+	
+	float fDistStartX = SQR(fX                       - fCamX);
+	float fDistStartY = SQR(fY                       - fCamY);
+	float fDistEndX   = SQR((fX + SMALL_SECTOR_SIZE) - fCamX);
+	float fDistEndY   = SQR((fY + SMALL_SECTOR_SIZE) - fCamY);
+	
+	
+	float fAlphaBlendMulA 
+			= Min(fFlatWaterBlendRange * Max(sqrt(fDistStartX + fDistStartY) - fBlendDrawDist, fMinWaterAlphaMult), 1.0f);
+	float fAlphaBlendMulB
+			= Min(fFlatWaterBlendRange * Max(sqrt(fDistStartX + fDistEndY  ) - fBlendDrawDist, fMinWaterAlphaMult), 1.0f);
+	float fAlphaBlendMulC
+			= Min(fFlatWaterBlendRange * Max(sqrt(fDistEndX   + fDistEndY  ) - fBlendDrawDist, fMinWaterAlphaMult), 1.0f);
+	float fAlphaBlendMulD
+			= Min(fFlatWaterBlendRange * Max(sqrt(fDistEndX   + fDistStartY) - fBlendDrawDist, fMinWaterAlphaMult), 1.0f);
+
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 0], fX, fY, fZ - _fWaterZOffset);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue,
+		(colorTrans.alpha + (color.alpha - colorTrans.alpha) * (uint8)(int32)fAlphaBlendMulA));
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + SMALL_SECTOR_SIZE, fZ - _fWaterZOffset);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 1], TEXTURE_ADDV + 1.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 1], color.red, color.green, color.blue,
+		(colorTrans.alpha + (color.alpha - colorTrans.alpha) * (uint8)(int32)fAlphaBlendMulB));
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + SMALL_SECTOR_SIZE, fY + SMALL_SECTOR_SIZE, fZ - _fWaterZOffset);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDU + 1.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 2], TEXTURE_ADDV + 1.0f);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 2], color.red, color.green, color.blue,
+		(colorTrans.alpha + (color.alpha - colorTrans.alpha) * (uint8)(int32)fAlphaBlendMulC));
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + SMALL_SECTOR_SIZE, fY, fZ - _fWaterZOffset);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDU + 1.0f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 3], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[vidx + 3], color.red, color.green, color.blue,
+		(colorTrans.alpha + (color.alpha - colorTrans.alpha) * (uint8)(int32)fAlphaBlendMulD));
+
+
+	int32 iidx = TempBufferIndicesStored;
+
+	TempBufferRenderIndexList[iidx + 0] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[iidx + 1] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[iidx + 2] = TempBufferVerticesStored + 1;
+	TempBufferRenderIndexList[iidx + 3] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[iidx + 4] = TempBufferVerticesStored + 3;
+	TempBufferRenderIndexList[iidx + 5] = TempBufferVerticesStored + 2;
+	
+	TempBufferVerticesStored += 4;
+
+	TempBufferIndicesStored += 6;
+}
+
 float
 CWaterLevel::CalcDistanceToWater(float fX, float fY)
 {
-	const float fSectorMaxRenderDist = 75.0f;
+	const float fSectorMaxRenderDist = 250.0f;
 	
 	int32 nStartX = WATER_TO_SMALL_SECTOR_X(fX - fSectorMaxRenderDist + WATER_X_OFFSET) - 1;
 	int32 nEndX   = WATER_TO_SMALL_SECTOR_X(fX + fSectorMaxRenderDist + WATER_X_OFFSET) + 1;
@@ -1127,7 +2585,7 @@ CWaterLevel::CalcDistanceToWater(float fX, float fY)
 	{
 		for ( int32 y = nStartY; y <= nEndY; y++ )
 		{
-			if ( !(aWaterFineBlockList[x][y] & 128) )
+			if ( !(aWaterFineBlockList[x][y] & 0x80) )
 			{				
 				float fSectorX = WATER_FROM_SMALL_SECTOR_X(x) - WATER_X_OFFSET;
 				float fSectorY = WATER_FROM_SMALL_SECTOR_Y(y);
@@ -1153,7 +2611,7 @@ CWaterLevel::RenderAndEmptyRenderBuffer()
 	{
 		LittleTest();
 
-		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, NULL, rwIM3D_VERTEXUV) )
+		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV) )
 		{
 			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
 			RwIm3DEnd();
@@ -1164,97 +2622,339 @@ CWaterLevel::RenderAndEmptyRenderBuffer()
 	TempBufferVerticesStored = 0;
 }
 
-void
-CWaterLevel::AllocateBoatWakeArray()
+bool
+CWaterLevel::GetGroundLevel(CVector const &vecPosn, float *pfOutLevel, ColData *pData, float fDistance)
 {
-	CStreaming::MakeSpaceFor(14 * CDSTREAM_SECTOR_SIZE); 
+	CColPoint point;
+	CEntity *entity;
+	
+	if ( !CWorld::ProcessVerticalLine(vecPosn + CVector(0.0f, 0.0f, fDistance),
+			-fDistance, point, entity, true, false, false, false, true, false, nil) )
+		return false;
+		
+	*pfOutLevel = point.point.z;
+	
+	if ( pData != nil )
+	{
+		pData->SurfaceType = point.surfaceB;
+		pData->PieceType   = point.pieceB;
+	}
+	
+	return true;
+}
+
+bool
+CWaterLevel::IsLocationOutOfWorldBounds_WS(CVector const &vecPosn, int nOffset)
+{
+	int32 x = int32((vecPosn.x / 50.0f) + 48.0f);
+	int32 y = int32((vecPosn.y / 50.0f) + 40.0f);
+	
+	return x < nOffset || x >= 80 - nOffset || y < nOffset || y >= 80 - nOffset;
+}
+
+bool
+CWaterLevel::GetGroundLevel_WS(CVector const &vecPosn, float *pfOutLevel, ColData *pData, float fDistance)
+{
+	if ( IsLocationOutOfWorldBounds_WS(vecPosn, 0) )
+		return false;
+	else
+		return GetGroundLevel(vecPosn, pfOutLevel, pData, fDistance);
+}
 
-	ASSERT(ms_pWavyAtomic != NULL );
+bool
+CWaterLevel::GetWaterDepth(CVector const &vecPosn, float *pfDepth, float *pfLevelNoWaves, float *pfGroundLevel)
+{
+	float fLevelNoWaves;
+	float fGroundLevel;
+	
+	if ( !GetWaterLevelNoWaves(vecPosn.x, vecPosn.y, vecPosn.z, &fLevelNoWaves) )
+		return false;
+	
+	if ( !GetGroundLevel(vecPosn, &fGroundLevel, nil, 30.0f) )
+		fGroundLevel = -100.0;
 	
-	RpGeometry    *wavyGeometry    = RpAtomicGetGeometry(ms_pWavyAtomic);
-	ASSERT(wavyGeometry    != NULL );
-	RpMorphTarget *wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
-	RpMaterial    *wavyMaterial    = RpGeometryGetMaterial(wavyGeometry, 0);
+	if ( pfDepth != nil )
+		*pfDepth = fLevelNoWaves - fGroundLevel;
 
-	ASSERT(wavyMorphTarget != NULL );
-	ASSERT(wavyMaterial    != NULL );
+	if ( pfLevelNoWaves != nil )
+		*pfLevelNoWaves = fLevelNoWaves;
 
-	for ( int32 geom = 0; geom < MAX_BOAT_WAKES; geom++ )
+	if ( pfGroundLevel != nil )
+		*pfGroundLevel = fGroundLevel;
+	
+	return true;
+}
+
+void
+CWaterLevel::RenderSeaBirds()
+{
+	CVector cur_pos = TheCamera.GetPosition();
+	
+	if ( !CCullZones::CamNoRain()
+		&& !CCullZones::PlayerNoRain()
+		&& (CWeather::NewWeatherType == WEATHER_SUNNY || CWeather::NewWeatherType == WEATHER_EXTRA_SUNNY)
+		&& CClock::ms_nGameClockHours > 6 && CClock::ms_nGameClockHours < 20 )
 	{
-		if ( apGeomArray[geom] == NULL )
+		static CVector prev_pos(0.0f, 0.0f, 0.0f);
+		static CVector prev_front(0.0f, 0.0f, 0.0f);
+		static int32 timecounter;
+
+		if ( Abs(prev_pos.x - cur_pos.x) + Abs(prev_pos.y - cur_pos.y) + Abs(prev_pos.z - cur_pos.z) > 1.5f )
 		{
-			apGeomArray[geom] = RpGeometryCreate(9*9, 8*8*2, rpGEOMETRYTRISTRIP
-															| rpGEOMETRYPRELIT
-															| rpGEOMETRYMODULATEMATERIALCOLOR
-															| rpGEOMETRYTEXTURED);
-			ASSERT(apGeomArray[geom] != NULL);
+			prev_pos = cur_pos;
+			timecounter = CTimer::GetTimeInMilliseconds();
+		}
+		else if ( (CTimer::GetTimeInMilliseconds() - timecounter) > 5000 )
+		{
+			static int32 birdgenTime = 0;
+			
+			if ( (CTimer::GetTimeInMilliseconds() - birdgenTime) > 1000 )
+			{
+				birdgenTime = CTimer::GetTimeInMilliseconds();
+				
+				CVector vecPos = cur_pos;
+				
+				float fAngle = CGeneral::GetRandomNumberInRange(90.0f, 150.0f);
+				
+				uint16 nSinCosIdx = CGeneral::GetRandomNumber() % (CParticle::SIN_COS_TABLE_SIZE-1);
+				
+				float fCos = CParticle::Cos(nSinCosIdx);
+				float fSin = CParticle::Sin(nSinCosIdx);
+
+				vecPos.x += (fCos - fSin) * fAngle;
+				vecPos.y += (fSin + fCos) * fAngle;
+				vecPos.z += CGeneral::GetRandomNumberInRange(10.0f, 30.0f);
+				
+				CVector vecDir(CGeneral::GetRandomNumberInRange(-1.0f, 1.0f),
+								CGeneral::GetRandomNumberInRange(-1.0f, 1.0f),
+								0.0f);
+				
+				CParticle::AddParticle(PARTICLE_BIRD_FRONT, vecPos, vecDir, nil, 0.0f, 0, 0, 0, 0);
+			}
+		}
+	}
+}
+
+void
+CWaterLevel::RenderShipsOnHorizon()
+{
+	CVector cur_pos = FindPlayerPed()->GetPosition();
+
+	static CVector prev_pos(0.0f, 0.0f, 0.0f);
+	static CVector prev_front(0.0f, 0.0f, 0.0f);
+	static int32 timecounter;
 
-			RpTriangle *geomTriangles = RpGeometryGetTriangles(apGeomArray[geom]);
+	if ( Abs(prev_pos.x - cur_pos.x) + Abs(prev_pos.y - cur_pos.y) + Abs(prev_pos.z - cur_pos.z) > 1.5f )
+	{
+		prev_pos = cur_pos;
+		timecounter = CTimer::GetTimeInMilliseconds();
+	}
+	else if ( (CTimer::GetTimeInMilliseconds() - timecounter) > 5000 )
+	{
+		static int32 shipgenTime = 0;
+		
+		if ( (CTimer::GetTimeInMilliseconds() - shipgenTime) > 4000 )
+		{
+			shipgenTime = CTimer::GetTimeInMilliseconds();
+			
+			CVector vecPos = cur_pos;
 			
-			ASSERT( geomTriangles != NULL );
+			float fAngle = CGeneral::GetRandomNumberInRange(450.0f, 750.0f);
+			
+			uint16 nSinCosIdx = CGeneral::GetRandomNumber() % (CParticle::SIN_COS_TABLE_SIZE-1);
+			
+			float fCos = CParticle::Cos(nSinCosIdx);
+			float fSin = CParticle::Sin(nSinCosIdx);
 
-			for ( int32 i = 0; i < 8; i++ )
+			vecPos.x += (fCos - fSin) * fAngle;
+			vecPos.y += (fSin + fCos) * fAngle;
+			
+			float fLevelNoWaves;
+			
+			if ( GetWaterLevelNoWaves(vecPos.x, vecPos.y, vecPos.z, &fLevelNoWaves) )
 			{
-				for ( int32 j = 0; j < 8; j++ )
+				if ( IsLocationOutOfWorldBounds_WS(vecPos, 1) )
 				{
+					vecPos.z  = fLevelNoWaves + 9.5f;
 					
-					/*  
-						[B]       [C]
-						 ***********
-						 *       * *
-						 *     *   *
-						 *   *     *
-						 * *       *
-						 ***********
-						[A]       [D]
-					*/
+					CVector vecDir
+					(
+						CGeneral::GetRandomNumberInRange(-0.1f, 0.1f),
+						0.0f,
+						0.0f
+					);
 					
-					
-					RpGeometryTriangleSetVertexIndices(apGeomArray[geom],
-						&geomTriangles[2 * 8*i + 2*j + 0], /*A*/i*9+j+0, /*B*/i*9+j+1,   /*C*/i*9+j+9+1);
-					
-					RpGeometryTriangleSetVertexIndices(apGeomArray[geom],
-						&geomTriangles[2 * 8*i + 2*j + 1], /*A*/i*9+j+0, /*C*/i*9+j+9+1, /*D*/i*9+j+9  );
-
-					RpGeometryTriangleSetMaterial(apGeomArray[geom], &geomTriangles[2 * 8*i + 2*j + 0], wavyMaterial);
-					
-					RpGeometryTriangleSetMaterial(apGeomArray[geom], &geomTriangles[2 * 8*i + 2*j + 1], wavyMaterial);
+					CParticle::AddParticle(PARTICLE_SHIP_SIDE, vecPos, vecDir,
+						nil, 0.0f, 0, 0, CGeneral::GetRandomNumber() & 7, 0);
 				}
 			}
+		}
+	}
+}
 
-			RpMorphTarget *geomMorphTarget = RpGeometryGetMorphTarget(apGeomArray[geom], 0);
-			RwV3d         *geomVertices    = RpMorphTargetGetVertices(geomMorphTarget);
-			
-			ASSERT( geomMorphTarget != NULL );
-			ASSERT( geomVertices != NULL );
+void
+CWaterLevel::HandleSeaLifeForms()
+{
+	if ( CReplay::IsPlayingBack() )
+		return;
+	
+	CVector cur_pos = FindPlayerPed()->GetPosition();
 
-			for ( int32 i = 0; i < 9; i++ )
+	static CVector prev_pos(0.0f, 0.0f, 0.0f);
+	static int32 timecounter;
+	
+	if ( Abs(prev_pos.x - cur_pos.x) + Abs(prev_pos.y - cur_pos.y) + Abs(prev_pos.z - cur_pos.z) > 1.5f )
+	{
+		prev_pos = cur_pos;
+		timecounter = CTimer::GetTimeInMilliseconds();
+	}
+	else if ( (CTimer::GetTimeInMilliseconds() - timecounter) > 5000 )
+	{
+//TODO(MIAMI)
+//		if ( CWaterCreatures::IsSpaceForMoreWaterCreatures() )
+		{
+			for ( int32 i = 0; i < 3; i++ )
 			{
-				for ( int32 j = 0; j < 9; j++ )
-				{
-					geomVertices[9*i+j].x = (float)i * 4.0f;
-					geomVertices[9*i+j].y = (float)j * 4.0f;
-					geomVertices[9*i+j].z = 0.0f;
-				}
+				CVector vecPos = cur_pos;
+				
+				float fAngle = CGeneral::GetRandomNumberInRange(15.0f, 30.0f);
+				
+				uint16 nSinCosIdx = CGeneral::GetRandomNumber() % (CParticle::SIN_COS_TABLE_SIZE-1);
+				
+				float fCos = CParticle::Cos(nSinCosIdx);
+				float fSin = CParticle::Sin(nSinCosIdx);
+				
+				vecPos.x += (fCos - fSin) * fAngle;
+				vecPos.y += (fSin + fCos) * fAngle;
+				
+				//TODO(MIAMI)
+				//CWaterCreatures::CreateOne(vecPos, 0xFFFFFFFF);
 			}
-
-			RpMorphTargetSetBoundingSphere(geomMorphTarget, RpMorphTargetGetBoundingSphere(wavyMorphTarget));			
-			RpGeometryUnlock(apGeomArray[geom]);
 		}
 	}
+	
+	//TODO(MIAMI)
+	//CWaterCreatures::UpdateAll();
 }
 
 void
-CWaterLevel::FreeBoatWakeArray()
+CWaterLevel::HandleBeachToysStuff(void)
 {
-	for ( int32 i = 0; i < MAX_BOAT_WAKES; i++ )
+	CVector cur_pos = FindPlayerPed()->GetPosition();
+	
+	static bool bBeachBallInit = true;
+	static CVector FirstBeachBallPos = cur_pos;
+	static bool bLoungeInit = true;
+	static CVector FirstLoungePos = cur_pos;
+	static CVector prev_pos(0.0f, 0.0f, 0.0f);
+	static int32 timecounter;
+
+	if ( Abs(prev_pos.x - cur_pos.x) + Abs(prev_pos.y - cur_pos.y) + Abs(prev_pos.z - cur_pos.z) > 1.5f )
+	{
+		prev_pos = cur_pos;
+		timecounter = CTimer::GetTimeInMilliseconds();
+	}
+	else if ( (CTimer::GetTimeInMilliseconds() - timecounter) > 5000 )
 	{
-		if ( apGeomArray[i] != NULL )
+		static int32 toygenTime = CTimer::GetTimeInMilliseconds();
+		
+		if ( (CTimer::GetTimeInMilliseconds() - toygenTime) > 20000 )
 		{
-			RpGeometryDestroy(apGeomArray[i]);
-			apGeomArray[i] = NULL;
+			toygenTime = CTimer::GetTimeInMilliseconds();
+			
+			if ( bBeachBallInit ||  (cur_pos - FirstBeachBallPos).MagnitudeSqr() > 6400.0f )
+			{
+				for ( int32 i = 0; i < 3; i++ )
+				{
+					CVector vecPos = cur_pos;
+					
+					float fAngle = CGeneral::GetRandomNumberInRange(20.0f, 35.0f);
+					
+					uint16 nSinCosIdx = CGeneral::GetRandomNumber() % (CParticle::SIN_COS_TABLE_SIZE-1);
+					
+					float fCos = CParticle::Cos(nSinCosIdx);
+					float fSin = CParticle::Sin(nSinCosIdx);
+					
+					vecPos.x += (fCos - fSin) * fAngle;
+					vecPos.y += (fSin + fCos) * fAngle;
+					
+					if ( TheCamera.IsSphereVisible(vecPos, 1.0f, &TheCamera.GetCameraMatrix()) )
+					{
+						float fWaterLevel;
+						
+						if ( !GetWaterLevel(vecPos.x, vecPos.y, vecPos.z, &fWaterLevel, false) )
+						{
+							float fGroundLevel;
+							ColData coldata;
+							
+							if ( GetGroundLevel(vecPos, &fGroundLevel, &coldata, 30.0f) )
+							{
+								if ( coldata.SurfaceType == SURFACE_SAND )
+								{
+									CEntity *toy = CreateBeachToy(vecPos, BEACHTOY_BALL);
+									
+									if ( toy )
+									{
+										FirstBeachBallPos = cur_pos;
+										bBeachBallInit = false;
+										i = 10;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			
+			if ( bLoungeInit ||  (cur_pos - FirstLoungePos).MagnitudeSqr() > 6400.0f )
+			{
+				for ( int32 i = 0; i < 5; i++ )
+				{
+					CVector vecPos = cur_pos;
+					
+					float fAngle = CGeneral::GetRandomNumberInRange(20.0f, 35.0f);
+					
+					uint16 nSinCosIdx = CGeneral::GetRandomNumber() % (CParticle::SIN_COS_TABLE_SIZE-1);
+					
+					float fCos = CParticle::Cos(nSinCosIdx);
+					float fSin = CParticle::Sin(nSinCosIdx);
+					
+					vecPos.x += (fCos - fSin) * fAngle;
+					vecPos.y += (fSin + fCos) * fAngle;
+					
+					if ( TheCamera.IsSphereVisible(vecPos, 2.0f, &TheCamera.GetCameraMatrix()) )
+					{
+						float fWaterLevel;
+						
+						if ( !GetWaterLevel(vecPos.x, vecPos.y, vecPos.z, &fWaterLevel, false) )
+						{
+							float fGroundLevel;
+							ColData coldata;
+							
+							if ( GetGroundLevel(vecPos, &fGroundLevel, &coldata, 30.0f) )
+							{
+								if ( coldata.SurfaceType == SURFACE_SAND )
+								{
+									CEntity *toy = CreateBeachToy(vecPos, BEACHTOY_LOUNGE);
+									if ( toy )
+									{
+										toy->SetHeading(DEGTORAD(CGeneral::GetRandomNumberInRange(0.0f, 359.0f)));
+										FirstLoungePos = cur_pos;
+										bLoungeInit = false;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
 		}
 	}
-	
-	nGeomUsed = 0;  
 }
+
+CEntity *
+CWaterLevel::CreateBeachToy(CVector const &vec, eBeachToy beachtoy)
+{
+	//TODO(MIAMI)
+	return nil;
+}
\ No newline at end of file
diff --git a/src/render/WaterLevel.h b/src/render/WaterLevel.h
index 435692c1..69f90745 100644
--- a/src/render/WaterLevel.h
+++ b/src/render/WaterLevel.h
@@ -2,8 +2,8 @@
 
 #define WATER_X_OFFSET (400.0f)
 
-#define WATER_BLOCK_SIZE     LARGE_SECTOR_SIZE
-#define WATER_FINEBLOCK_SIZE HUGE_SECTOR_SIZE
+#define WATER_BLOCK_SECTORS     MAX_LARGE_SECTORS
+#define WATER_FINEBLOCK_SECTORS MAX_SMALL_SECTORS
 #define WATER_Z_OFFSET (0.5f)
 
 #define MAX_SMALL_SECTORS      128
@@ -31,6 +31,14 @@
 #define WATER_SIGN_X(x)                     ( (x) - (WATER_WIDTH /2) )
 #define WATER_SIGN_Y(y)                     ( (y) - (WATER_HEIGHT/2) )
 
+// 64x64 Large blocks 64x64 each
+#define WATER_TO_BLOCK_X(x)             ( WATER_UNSIGN_X(x) / WATER_BLOCK_SECTORS )
+#define WATER_TO_BLOCK_Y(x)             ( WATER_UNSIGN_Y(x) / WATER_BLOCK_SECTORS ) 
+
+// 128x128 Small blocks 32x32 each
+#define WATER_TO_FINEBLOCK_X(x)         ( WATER_UNSIGN_X(x) / WATER_FINEBLOCK_SECTORS )
+#define WATER_TO_FINEBLOCK_Y(x)         ( WATER_UNSIGN_Y(x) / WATER_FINEBLOCK_SECTORS ) 
+ 
 // 32
 #define WATER_SMALL_X(x)                    ( WATER_UNSIGN_X(x)					/ MAX_SMALL_SECTORS     )
 #define WATER_SMALL_Y(y)                    ( WATER_UNSIGN_Y(y)					/ MAX_SMALL_SECTORS     )
@@ -63,39 +71,105 @@
 #define WATER_TO_EXTRAHUGE_SECTOR_X(x)      ( WATER_UNSIGN_X(x)					/ EXTRAHUGE_SECTOR_SIZE )
 #define WATER_TO_EXTRAHUGE_SECTOR_Y(y)      ( WATER_UNSIGN_Y(y)					/ EXTRAHUGE_SECTOR_SIZE )
 
+struct ColData
+{
+	uint8 SurfaceType;
+	uint8 PieceType;
+};
 
-#define MAX_BOAT_WAKES 8
+enum eBeachToy
+{
+	BEACHTOY_0 = 0,
+	BEACHTOY_BALL,
+	BEACHTOY_2,
+	BEACHTOY_3,
+	BEACHTOY_4,
+	BEACHTOY_LOUNGE = 5
+};
 
 extern RwRaster* gpWaterRaster;
 
+class CEntity;
+
 class CWaterLevel
 {
+public:
 	static int32       ms_nNoOfWaterLevels;
 	static float       ms_aWaterZs[48];
 	static CRect       ms_aWaterRects[48];
-	static uint8       aWaterBlockList[WATER_BLOCK_SIZE][WATER_BLOCK_SIZE];
-	static uint8       aWaterFineBlockList[WATER_FINEBLOCK_SIZE][WATER_FINEBLOCK_SIZE];
+	static uint8       aWaterBlockList[WATER_BLOCK_SECTORS][WATER_BLOCK_SECTORS];				// 64x64 Large blocks 64x64 each
+	static uint8       aWaterFineBlockList[WATER_FINEBLOCK_SECTORS][WATER_FINEBLOCK_SECTORS];  // 128x128 Small blocks 32x32 each
 	static bool        WavesCalculatedThisFrame;
-	static RpAtomic   *ms_pWavyAtomic;
-	static RpGeometry *apGeomArray[MAX_BOAT_WAKES];
-	static int16       nGeomUsed;
+	
+	static bool        RequireWavySector;
+	static bool        MaskCalculatedThisFrame;
+	static CVector     PreCalculatedMaskPosn;
+	static bool        m_bRenderSeaBed;
+	static int32       m_nRenderWaterLayers;
+	
+	static RpAtomic    *ms_pWavyAtomic;
+	static RpAtomic    *ms_pMaskAtomic;
 
-public:
-	static void    Initialise(Const char *pWaterDat);
 	static void    Shutdown();
+	
 	static void    CreateWavyAtomic();
 	static void    DestroyWavyAtomic();
+	
+	
 	static bool    GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool bDontCheckZ);
 	static bool    GetWaterLevel(CVector coors, float *pfOutLevel, bool bDontCheckZ) { return GetWaterLevel(coors.x, coors.y, coors.z, pfOutLevel, bDontCheckZ); }
 	static bool    GetWaterLevelNoWaves(float fX, float fY, float fZ, float *pfOutLevel);
+	static float   GetWaterWavesOnly(short x, short y);	// unused
+	static CVector GetWaterNormal(float fX, float fY);
+	
 	static void    RenderWater();
-	static void    RenderOneFlatSmallWaterPoly    (float fX, float fY, float fZ, RwRGBA const &color);
-	static void    RenderOneFlatLargeWaterPoly    (float fX, float fY, float fZ, RwRGBA const &color);	
-	static void    RenderOneFlatHugeWaterPoly     (float fX, float fY, float fZ, RwRGBA const &color);
-	static void    RenderOneFlatExtraHugeWaterPoly(float fX, float fY, float fZ, RwRGBA const &color);
-	static void    RenderOneWavySector            (float fX, float fY, float fZ, RwRGBA const &color, bool bUnk = false);
-	static float   CalcDistanceToWater(float fX, float fY);
-	static void    RenderAndEmptyRenderBuffer();	
-	static void    AllocateBoatWakeArray();
-	static void    FreeBoatWakeArray();
+	static void    RenderTransparentWater(void);
+	// unused 
+	static void RenderOneFlatSmallWaterPoly    (float fX, float fY, float fZ, RwRGBA const &color);
+	// inlined
+	static void RenderOneFlatLargeWaterPoly    (float fX, float fY, float fZ, RwRGBA const &color);	
+	static void RenderOneFlatHugeWaterPoly     (float fX, float fY, float fZ, RwRGBA const &color);
+	static void RenderOneFlatExtraHugeWaterPoly(float fX, float fY, float fZ, RwRGBA const &color);
+	// inlined
+	static void RenderOneWavySector            (float fX, float fY, float fZ, RwRGBA const &color, bool bDontRender = false);
+	// unused
+#ifdef PC_WATER
+	static void RenderWavyMask(float fX, float fY, float fZ, float fSectorX, float fSectorY, float fCamPosX, float fCamPosY, float fCamDirX, float fCamDirY, RwRGBA const&color);
+#else
+	static void RenderWavyMask(float fX, float fY, float fZ, float fSectorX, float fSectorY, int32 nCamDirX, int32 nCamDirY, RwRGBA const&color);
+#endif
+
+#ifdef PC_WATER
+	static void PreCalcWaterGeometry(void);
+	static bool PreCalcWavySector(RwRGBA const &color);	//fucked up
+	static bool PreCalcWavyMask(float fX, float fY, float fZ, float fSectorX, float fSectorY, float fCamPosX, float fCamPosY, float fCamDirX, float fCamDirY, RwRGBA const&color);
+#endif
+		
+	
+	static void RenderBoatWakes(void);
+	static void RenderWakeSegment(CVector2D &vecA, CVector2D &vecB, CVector2D &vecC, CVector2D &vecD, float &fSizeA, float &fSizeB, float &fAlphaA, float &fAlphaB, float &fWakeZ);
+	
+	// unused
+	static void RenderOneSlopedUnderWaterPoly(float fX, float fY, float fZ, RwRGBA const&color); // UNUSED
+	static void RenderOneFlatSmallWaterPolyBlended(float fX, float fY, float fZ, float fCamX, float fCamY, RwRGBA const &color, RwRGBA const &colorTrans, float fDrawDist);
+	static float CalcDistanceToWater(float fX, float fY);
+	static void RenderAndEmptyRenderBuffer();
+	
+	static bool GetGroundLevel(CVector const &vecPosn, float *pfOutLevel, ColData *pData, float fDistance);
+	
+	// unused
+	static bool IsLocationOutOfWorldBounds_WS(CVector const &vecPosn, int nOffset);
+	// unused
+	static bool GetGroundLevel_WS(CVector const & vecPosn, float *pfOutLevel, ColData *pData, float fDistance);
+	static bool GetWaterDepth(CVector const &vecPosn, float *pfDepth, float *pfLevelNoWaves, float *pfGroundLevel);
+	
+	static void RenderSeaBirds();
+	static void RenderShipsOnHorizon();
+	
+	static void HandleSeaLifeForms();
+	
+	static void HandleBeachToysStuff(void);
+	static CEntity *CreateBeachToy(CVector const &vec, eBeachToy beachtoy);
 };
+
+extern void WaterLevelInitialise(Const char *datFile);
\ No newline at end of file
diff --git a/src/vehicles/Boat.cpp b/src/vehicles/Boat.cpp
index 66e83c8f..99b6cbb8 100644
--- a/src/vehicles/Boat.cpp
+++ b/src/vehicles/Boat.cpp
@@ -27,12 +27,12 @@
 
 float fShapeLength = 0.4f;
 float fShapeTime = 0.05f;
-float fRangeMult = 0.75f; //0.6f; // 0.75f gta 3
+float fRangeMult = 0.6f;
 float fTimeMult;
 
-float MAX_WAKE_LENGTH = 50.0f;
-float MIN_WAKE_INTERVAL = 1.0f;
-float WAKE_LIFETIME = 400.0f;
+float CBoat::MAX_WAKE_LENGTH = 50.0f;
+float CBoat::MIN_WAKE_INTERVAL = 2.0f;
+float CBoat::WAKE_LIFETIME = 150.0f;
 
 CBoat *CBoat::apFrameWakeGeneratingBoats[4];
 
diff --git a/src/vehicles/Boat.h b/src/vehicles/Boat.h
index c8168db0..c6f4b7ad 100644
--- a/src/vehicles/Boat.h
+++ b/src/vehicles/Boat.h
@@ -45,6 +45,10 @@ public:
 	CVector2D m_avec2dWakePoints[32];
 	float m_afWakePointLifeTime[32];
 
+	static float MAX_WAKE_LENGTH;
+	static float MIN_WAKE_INTERVAL;
+	static float WAKE_LIFETIME;
+
 	CBoat(int, uint8);
 
 	virtual void SetModelIndex(uint32 id);
@@ -75,8 +79,4 @@ public:
 #endif
 	static const uint32 nSaveStructSize;
 
-};
-
-extern float MAX_WAKE_LENGTH;
-extern float MIN_WAKE_INTERVAL;
-extern float WAKE_LIFETIME;
\ No newline at end of file
+};
\ No newline at end of file