62 files changed, 21715 insertions, 0 deletions

diff --git a/src/renderer/2dEffect.h b/src/renderer/2dEffect.h
new file mode 100644
index 00000000..a8013b34
--- /dev/null
+++ b/src/renderer/2dEffect.h
@@ -0,0 +1,93 @@
+#pragma once
+
+enum {
+	EFFECT_LIGHT,
+	EFFECT_PARTICLE,
+	EFFECT_ATTRACTOR
+};
+
+enum {
+	LIGHT_ON,
+	LIGHT_ON_NIGHT,
+	LIGHT_FLICKER,
+	LIGHT_FLICKER_NIGHT,
+	LIGHT_FLASH1,
+	LIGHT_FLASH1_NIGHT,
+	LIGHT_FLASH2,
+	LIGHT_FLASH2_NIGHT,
+	LIGHT_FLASH3,
+	LIGHT_FLASH3_NIGHT,
+	LIGHT_RANDOM_FLICKER,
+	LIGHT_RANDOM_FLICKER_NIGHT,
+	LIGHT_SPECIAL,
+	LIGHT_BRIDGE_FLASH1,
+	LIGHT_BRIDGE_FLASH2,
+};
+
+enum {
+	ATTRACTORTYPE_ICECREAM,
+	ATTRACTORTYPE_STARE
+};
+
+enum {
+	LIGHTFLAG_LOSCHECK = 1,
+	// same order as CPointLights flags, must start at 2
+	LIGHTFLAG_FOG_NORMAL = 2,	// can have light and fog
+	LIGHTFLAG_FOG_ALWAYS = 4,	// fog only
+	LIGHTFLAG_FOG = (LIGHTFLAG_FOG_NORMAL|LIGHTFLAG_FOG_ALWAYS)
+};
+
+class C2dEffect
+{
+public:
+	struct Light {
+		float dist;
+		float range;	// of pointlight
+		float size;
+		float shadowSize;
+		uint8 lightType;	// LIGHT_
+		uint8 roadReflection;
+		uint8 flareType;
+		uint8 shadowIntensity;
+		uint8 flags;		// LIGHTFLAG_
+		RwTexture *corona;
+		RwTexture *shadow;
+	};
+	struct Particle {
+		int particleType;
+		CVector dir;
+		float scale;
+	};
+	struct Attractor {
+		CVector dir;
+		int8 type;
+		uint8 probability;
+	};
+
+	CVector pos;
+	CRGBA col;
+	uint8 type;
+	union {
+		Light light;
+		Particle particle;
+		Attractor attractor;
+	};
+
+	C2dEffect(void) {}
+	void Shutdown(void){
+		if(type == EFFECT_LIGHT){
+			if(light.corona)
+				RwTextureDestroy(light.corona);
+#if GTA_VERSION >= GTA3_PC_11
+			light.corona = nil;
+#endif
+			if(light.shadow)
+				RwTextureDestroy(light.shadow);
+#if GTA_VERSION >= GTA3_PC_11
+			light.shadow = nil;
+#endif
+		}
+	}
+};
+
+VALIDATE_SIZE(C2dEffect, 0x34);
diff --git a/src/renderer/Antennas.cpp b/src/renderer/Antennas.cpp
new file mode 100644
index 00000000..5e30aca2
--- /dev/null
+++ b/src/renderer/Antennas.cpp
@@ -0,0 +1,129 @@
+#include "common.h"
+
+#include "main.h"
+#include "Antennas.h"
+
+CAntenna CAntennas::aAntennas[NUMANTENNAS];
+
+void
+CAntennas::Init(void)
+{
+	int i;
+	for(i = 0; i < NUMANTENNAS; i++){
+		aAntennas[i].active = false;
+		aAntennas[i].updatedLastFrame = false;
+	}
+}
+
+// Free antennas that aren't used anymore
+void
+CAntennas::Update(void)
+{
+	int i;
+
+	for(i = 0; i < NUMANTENNAS; i++){
+		if(aAntennas[i].active && !aAntennas[i].updatedLastFrame)
+			aAntennas[i].active = false;
+		aAntennas[i].updatedLastFrame = false;
+	}
+}
+
+// Add a new one or update an old one
+void
+CAntennas::RegisterOne(uint32 id, CVector dir, CVector position, float length)
+{
+	int i, j;
+
+	for(i = 0; i < NUMANTENNAS; i++)
+		if(aAntennas[i].active && aAntennas[i].id == id)
+			break;
+
+	if(i >= NUMANTENNAS){
+		// not found, register new one
+
+		// find empty slot
+		for(i = 0; i < NUMANTENNAS; i++)
+			if(!aAntennas[i].active)
+				break;
+
+		// there is space
+		if(i < NUMANTENNAS){
+			aAntennas[i].active = true;
+			aAntennas[i].updatedLastFrame = true;
+			aAntennas[i].id = id;
+			aAntennas[i].segmentLength = length/6.0f;
+			for(j = 0; j < 6; j++){
+				aAntennas[i].pos[j] = position + dir*j*aAntennas[i].segmentLength;
+				aAntennas[i].speed[j] = CVector(0.0f, 0.0f, 0.0f);
+			}
+		}
+	}else{
+		// found, update
+		aAntennas[i].Update(dir, position);
+		aAntennas[i].updatedLastFrame = true;
+	}
+}
+
+static RwIm3DVertex vertexbufferA[2];
+
+void
+CAntennas::Render(void)
+{
+	int i, j;
+
+	PUSH_RENDERGROUP("CAntennas::Render");
+	for(i = 0; i < NUMANTENNAS; i++){
+		if(!aAntennas[i].active)
+			continue;
+
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+
+		for(j = 0; j < 5; j++){
+			RwIm3DVertexSetRGBA(&vertexbufferA[0], 200, 200, 200, 100);
+			RwIm3DVertexSetPos(&vertexbufferA[0],
+				aAntennas[i].pos[j].x,
+				aAntennas[i].pos[j].y,
+				aAntennas[i].pos[j].z);
+			RwIm3DVertexSetRGBA(&vertexbufferA[1], 200, 200, 200, 100);
+			RwIm3DVertexSetPos(&vertexbufferA[1],
+				aAntennas[i].pos[j+1].x,
+				aAntennas[i].pos[j+1].y,
+				aAntennas[i].pos[j+1].z);
+
+			// LittleTest();
+			if(RwIm3DTransform(vertexbufferA, 2, nil, 0)){
+				RwIm3DRenderLine(0, 1);
+				RwIm3DEnd();
+			}
+		}
+	}
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+
+	POP_RENDERGROUP();
+}
+
+void
+CAntenna::Update(CVector dir, CVector basepos)
+{
+	int i;
+
+	pos[0] = basepos;
+	pos[1] = basepos + dir*segmentLength;
+
+	for(i = 2; i < 6; i++){
+		CVector basedir = pos[i-1] - pos[i-2];
+		CVector newdir = pos[i] - pos[i-1] +	// drag along
+			dir*0.1f +	// also drag up a bit for stiffness
+			speed[i];	// and keep moving
+		newdir.Normalise();
+		newdir *= segmentLength;
+		CVector newpos = pos[i-1] + (basedir + newdir)/2.0f;
+		speed[i] = (newpos - pos[i])*0.9f;
+		pos[i] = newpos;
+	}
+}
diff --git a/src/renderer/Antennas.h b/src/renderer/Antennas.h
new file mode 100644
index 00000000..47cb1dad
--- /dev/null
+++ b/src/renderer/Antennas.h
@@ -0,0 +1,25 @@
+#pragma once
+
+class CAntenna
+{
+public:
+	bool active;
+	bool updatedLastFrame;
+	uint32 id;
+	float segmentLength;
+	CVector pos[6];
+	CVector speed[6];
+
+	void Update(CVector dir, CVector pos);
+};
+
+class CAntennas
+{
+	// no need to use game's array
+	static CAntenna aAntennas[NUMANTENNAS];
+public:
+	static void Init(void);
+	static void Update(void);
+	static void RegisterOne(uint32 id, CVector dir, CVector position, float length);
+	static void Render(void);
+};
diff --git a/src/renderer/Clouds.cpp b/src/renderer/Clouds.cpp
new file mode 100644
index 00000000..957844a5
--- /dev/null
+++ b/src/renderer/Clouds.cpp
@@ -0,0 +1,466 @@
+#include "common.h"
+
+#include "main.h"
+#include "Sprite.h"
+#include "Sprite2d.h"
+#include "General.h"
+#include "Coronas.h"
+#include "Camera.h"
+#include "TxdStore.h"
+#include "Weather.h"
+#include "Clock.h"
+#include "Timer.h"
+#include "Timecycle.h"
+#include "Renderer.h"
+#include "Clouds.h"
+
+#define SMALLSTRIPHEIGHT 4.0f
+#define HORIZSTRIPHEIGHT 48.0f
+
+RwTexture *gpCloudTex[5];
+
+float CClouds::CloudRotation;
+uint32 CClouds::IndividualRotation;
+
+float CClouds::ms_cameraRoll;
+float CClouds::ms_horizonZ;
+CRGBA CClouds::ms_colourTop;
+CRGBA CClouds::ms_colourBottom;
+
+void
+CClouds::Init(void)
+{
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(CTxdStore::FindTxdSlot("particle"));
+	gpCloudTex[0] = RwTextureRead("cloud1", nil);
+	gpCloudTex[1] = RwTextureRead("cloud2", nil);
+	gpCloudTex[2] = RwTextureRead("cloud3", nil);
+	gpCloudTex[3] = RwTextureRead("cloudhilit", nil);
+	gpCloudTex[4] = RwTextureRead("cloudmasked", nil);
+	CTxdStore::PopCurrentTxd();
+	CloudRotation = 0.0f;
+}
+
+void
+CClouds::Shutdown(void)
+{
+	RwTextureDestroy(gpCloudTex[0]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex[0] = nil;
+#endif
+	RwTextureDestroy(gpCloudTex[1]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex[1] = nil;
+#endif
+	RwTextureDestroy(gpCloudTex[2]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex[2] = nil;
+#endif
+	RwTextureDestroy(gpCloudTex[3]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex[3] = nil;
+#endif
+	RwTextureDestroy(gpCloudTex[4]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex[4] = nil;
+#endif
+}
+
+void
+CClouds::Update(void)
+{
+	float s = Sin(TheCamera.Orientation - 0.85f);
+#ifdef FIX_BUGS
+	CloudRotation += CWeather::Wind*s*0.0025f*CTimer::GetTimeStepFix();
+	IndividualRotation += (CWeather::Wind*CTimer::GetTimeStep() + 0.3f*CTimer::GetTimeStepFix()) * 60.0f;
+#else
+	CloudRotation += CWeather::Wind*s*0.0025f;
+	IndividualRotation += (CWeather::Wind*CTimer::GetTimeStep() + 0.3f) * 60.0f;
+#endif
+}
+
+float StarCoorsX[9] = { 0.0f, 0.05f, 0.12f, 0.5f, 0.8f, 0.6f, 0.27f, 0.55f, 0.75f };
+float StarCoorsY[9] = { 0.0f, 0.45f, 0.9f, 1.0f, 0.85f, 0.52f, 0.48f, 0.35f, 0.2f };
+float StarSizes[9] = { 1.0f, 1.4f, 0.9f, 1.0f, 0.6f, 1.5f, 1.3f, 1.0f, 0.8f };
+
+float LowCloudsX[12] = { 1.0f, 0.7f, 0.0f, -0.7f, -1.0f, -0.7f, 0.0f, 0.7f, 0.8f, -0.8f, 0.4f, -0.4f };
+float LowCloudsY[12] = { 0.0f, -0.7f, -1.0f, -0.7f, 0.0f, 0.7f, 1.0f, 0.7f, 0.4f, 0.4f, -0.8f, -0.8f };
+float LowCloudsZ[12] = { 0.0f, 1.0f, 0.5f, 0.0f, 1.0f, 0.3f, 0.9f, 0.4f, 1.3f, 1.4f, 1.2f, 1.7f };
+
+float CoorsOffsetX[37] = {
+	0.0f, 60.0f, 72.0f, 48.0f, 21.0f, 12.0f,
+	9.0f, -3.0f, -8.4f, -18.0f, -15.0f, -36.0f,
+	-40.0f, -48.0f, -60.0f, -24.0f, 100.0f, 100.0f,
+	100.0f, 100.0f, 100.0f, 100.0f, 100.0f, 100.0f,
+	100.0f, 100.0f, -30.0f, -20.0f, 10.0f, 30.0f,
+	0.0f, -100.0f, -100.0f, -100.0f, -100.0f, -100.0f, -100.0f
+};
+float CoorsOffsetY[37] = {
+	100.0f, 100.0f, 100.0f, 100.0f, 100.0f, 100.0f,
+	100.0f, 100.0f, 100.0f, 100.0f, 100.0f, 100.0f,
+	100.0f, 100.0f, 100.0f, 100.0f, -30.0f, 10.0f,
+	-25.0f, -5.0f, 28.0f, -10.0f, 10.0f, 0.0f,
+	15.0f, 40.0f, -100.0f, -100.0f, -100.0f, -100.0f,
+	-100.0f, -40.0f, -20.0f, 0.0f, 10.0f, 30.0f, 35.0f
+};
+float CoorsOffsetZ[37] = {
+	2.0f, 1.0f, 0.0f, 0.3f, 0.7f, 1.4f,
+	1.7f, 0.24f, 0.7f, 1.3f, 1.6f, 1.0f,
+	1.2f, 0.3f, 0.7f, 1.4f, 0.0f, 0.1f,
+	0.5f, 0.4f, 0.55f, 0.75f, 1.0f, 1.4f,
+	1.7f, 2.0f, 2.0f, 2.3f, 1.9f, 2.4f,
+	2.0f, 2.0f, 1.5f, 1.2f, 1.7f, 1.5f, 2.1f
+};
+
+uint8 BowRed[6] = { 30, 30, 30, 10, 0, 15 };
+uint8 BowGreen[6] = { 0, 15, 30, 30, 0, 0 };
+uint8 BowBlue[6] = { 0, 0, 0, 10, 30, 30 };
+
+void
+CClouds::Render(void)
+{
+	int i;
+	float szx, szy;
+	RwV3d screenpos;
+	RwV3d worldpos;
+
+	PUSH_RENDERGROUP("CClouds::Render");
+
+	CCoronas::SunBlockedByClouds = false;
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+	CSprite::InitSpriteBuffer();
+
+	int minute = CClock::GetHours()*60 + CClock::GetMinutes();
+	RwV3d campos = TheCamera.GetPosition();
+
+	// Moon
+	int moonfadeout = Abs(minute - 180);	// fully visible at 3AM
+	if(moonfadeout < 180){			// fade in/out 3 hours
+		float coverage = Max(CWeather::Foggyness, CWeather::CloudCoverage);
+		int brightness = (1.0f - coverage) * (180 - moonfadeout);
+		RwV3d pos = { 0.0f, -100.0f, 15.0f };
+		RwV3dAdd(&worldpos, &campos, &pos);
+		if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false)){
+			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[2]));
+			if(CCoronas::bSmallMoon){
+				szx *= 4.0f;
+				szy *= 4.0f;
+			}else{
+				szx *= 10.0f;
+				szy *= 10.0f;
+			}
+			CSprite::RenderOneXLUSprite(screenpos.x, screenpos.y, screenpos.z,
+				szx, szy, brightness, brightness, brightness, 255, 1.0f/screenpos.z, 255);
+		}
+	}
+
+	// The R* logo
+	int starintens = 0;
+	if(CClock::GetHours() < 22 && CClock::GetHours() > 5)
+		starintens = 0;
+	else if(CClock::GetHours() > 22 || CClock::GetHours() < 5)
+		starintens = 255;
+	else if(CClock::GetHours() == 22)
+		starintens = 255 * CClock::GetMinutes()/60.0f;
+	else if(CClock::GetHours() == 5)
+		starintens = 255 * (60 - CClock::GetMinutes())/60.0f;
+	if(starintens != 0){
+		float coverage = Max(CWeather::Foggyness, CWeather::CloudCoverage);
+		int brightness = (1.0f - coverage) * starintens;
+
+		// R
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[0]));
+		for(i = 0; i < 11; i++){
+			RwV3d pos = { 100.0f, 0.0f, 10.0f };
+			if(i >= 9) pos.x = -pos.x;
+			RwV3dAdd(&worldpos, &campos, &pos);
+			worldpos.y -= 90.0f*StarCoorsX[i%9];
+			worldpos.z += 80.0f*StarCoorsY[i%9];
+			if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false)){
+				float sz = 0.8f*StarSizes[i%9];
+				CSprite::RenderBufferedOneXLUSprite(screenpos.x, screenpos.y, screenpos.z,
+					szx*sz, szy*sz, brightness, brightness, brightness, 255, 1.0f/screenpos.z, 255);
+			}
+		}
+		CSprite::FlushSpriteBuffer();
+
+		// *
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[0]));
+		RwV3d pos = { 100.0f, 0.0f, 10.0f };
+		RwV3dAdd(&worldpos, &campos, &pos);
+		worldpos.y -= 90.0f;
+		if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false)){
+			brightness *= (CGeneral::GetRandomNumber()&127) / 640.0f + 0.5f;
+			CSprite::RenderOneXLUSprite(screenpos.x, screenpos.y, screenpos.z,
+				szx*5.0f, szy*5.0f, brightness, brightness, brightness, 255, 1.0f/screenpos.z, 255);
+		}
+	}
+
+	// Low clouds
+	float lowcloudintensity = 1.0f - Max(CWeather::Foggyness, CWeather::CloudCoverage);
+	int r = CTimeCycle::GetLowCloudsRed() * lowcloudintensity;
+	int g = CTimeCycle::GetLowCloudsGreen() * lowcloudintensity;
+	int b = CTimeCycle::GetLowCloudsBlue() * lowcloudintensity;
+	for(int cloudtype = 0; cloudtype < 3; cloudtype++){
+		for(i = cloudtype; i < 12; i += 3){
+			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCloudTex[cloudtype]));
+			RwV3d pos = { 800.0f*LowCloudsX[i], 800.0f*LowCloudsY[i], 60.0f*LowCloudsZ[i] };
+			worldpos.x = campos.x + pos.x;
+			worldpos.y = campos.y + pos.y;
+			worldpos.z = 40.0f + pos.z;
+			if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false))
+				CSprite::RenderBufferedOneXLUSprite_Rotate_Dimension(screenpos.x, screenpos.y, screenpos.z,
+					szx*320.0f, szy*40.0f, r, g, b, 255, 1.0f/screenpos.z, ms_cameraRoll, 255);
+		}
+		CSprite::FlushSpriteBuffer();
+	}
+
+	// Fluffy clouds
+	float rot_sin = Sin(CloudRotation);
+	float rot_cos = Cos(CloudRotation);
+	int fluffyalpha = 160 * (1.0f - CWeather::Foggyness);
+	if(fluffyalpha != 0){
+		static bool bCloudOnScreen[37];
+		float hilight;
+
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCloudTex[4]));
+		for(i = 0; i < 37; i++){
+			RwV3d pos = { 2.0f*CoorsOffsetX[i], 2.0f*CoorsOffsetY[i], 40.0f*CoorsOffsetZ[i] + 40.0f };
+			worldpos.x = pos.x*rot_cos + pos.y*rot_sin + campos.x;
+			worldpos.y = pos.x*rot_sin - pos.y*rot_cos + campos.y;
+			worldpos.z = pos.z;
+
+			if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false)){
+				float sundist = Sqrt(sq(screenpos.x-CCoronas::SunScreenX) + sq(screenpos.y-CCoronas::SunScreenY));
+				int tr = CTimeCycle::GetFluffyCloudsTopRed();
+				int tg = CTimeCycle::GetFluffyCloudsTopGreen();
+				int tb = CTimeCycle::GetFluffyCloudsTopBlue();
+				int br = CTimeCycle::GetFluffyCloudsBottomRed();
+				int bg = CTimeCycle::GetFluffyCloudsBottomGreen();
+				int bb = CTimeCycle::GetFluffyCloudsBottomBlue();
+				if(sundist < SCREEN_WIDTH/2){
+					hilight = (1.0f - Max(CWeather::Foggyness, CWeather::CloudCoverage)) * (1.0f - sundist/(SCREEN_WIDTH/2));
+					tr = tr*(1.0f-hilight) + 255*hilight;
+					tg = tg*(1.0f-hilight) + 190*hilight;
+					tb = tb*(1.0f-hilight) + 190*hilight;
+					br = br*(1.0f-hilight) + 255*hilight;
+					bg = bg*(1.0f-hilight) + 190*hilight;
+					bb = bb*(1.0f-hilight) + 190*hilight;
+					if(sundist < SCREEN_WIDTH/10)
+						CCoronas::SunBlockedByClouds = true;
+				}else
+					hilight = 0.0f;
+				CSprite::RenderBufferedOneXLUSprite_Rotate_2Colours(screenpos.x, screenpos.y, screenpos.z,
+					szx*55.0f, szy*55.0f,
+					tr, tg, tb, br, bg, bb, 0.0f, -1.0f,
+					1.0f/screenpos.z,
+					(uint16)IndividualRotation/65336.0f * 6.28f + ms_cameraRoll,
+					fluffyalpha);
+				bCloudOnScreen[i] = true;
+			}else
+				bCloudOnScreen[i] = false;
+		}
+		CSprite::FlushSpriteBuffer();
+
+		// Highlights
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCloudTex[3]));
+
+		for(i = 0; i < 37; i++){
+			RwV3d pos = { 2.0f*CoorsOffsetX[i], 2.0f*CoorsOffsetY[i], 40.0f*CoorsOffsetZ[i] + 40.0f };
+			worldpos.x = pos.x*rot_cos + pos.y*rot_sin + campos.x;
+			worldpos.y = pos.x*rot_sin - pos.y*rot_cos + campos.y;
+			worldpos.z = pos.z;
+			if(bCloudOnScreen[i] && CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false)){
+				// BUG: this is stupid....would have to do this for each cloud individually
+				if(hilight > 0.0f){
+					CSprite::RenderBufferedOneXLUSprite_Rotate_Aspect(screenpos.x, screenpos.y, screenpos.z,
+						szx*30.0f, szy*30.0f,
+						200*hilight, 0, 0, 255, 1.0f/screenpos.z,
+						1.7f - CGeneral::GetATanOfXY(screenpos.x-CCoronas::SunScreenX, screenpos.y-CCoronas::SunScreenY) + CClouds::ms_cameraRoll, 255);
+				}
+			}
+		}
+		CSprite::FlushSpriteBuffer();
+	}
+
+	// Rainbow
+	if(CWeather::Rainbow != 0.0f){
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[0]));
+		for(i = 0; i < 6; i++){
+			RwV3d pos = { i*1.5f, 100.0f, 5.0f };
+			RwV3dAdd(&worldpos, &campos, &pos);
+			if(CSprite::CalcScreenCoors(worldpos, &screenpos, &szx, &szy, false))
+				CSprite::RenderBufferedOneXLUSprite(screenpos.x, screenpos.y, screenpos.z,
+					2.0f*szx, 50.0*szy,
+					BowRed[i]*CWeather::Rainbow, BowGreen[i]*CWeather::Rainbow, BowBlue[i]*CWeather::Rainbow,
+					255, 1.0f/screenpos.z, 255);
+
+		}
+		CSprite::FlushSpriteBuffer();
+	}
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	POP_RENDERGROUP();
+}
+
+bool
+UseDarkBackground(void)
+{
+	return TheCamera.GetForward().z < -0.9f || gbShowCollisionPolys;
+}
+
+void
+CClouds::RenderBackground(int16 topred, int16 topgreen, int16 topblue,
+	int16 botred, int16 botgreen, int16 botblue, int16 alpha)
+{
+	PUSH_RENDERGROUP("CClouds::RenderBackground");
+
+	CVector left = TheCamera.GetRight();
+	float c = left.Magnitude2D();
+	if(c > 1.0f)
+		c = 1.0f;
+	ms_cameraRoll = Acos(c);
+	if(left.z < 0.0f)
+		ms_cameraRoll = -ms_cameraRoll;
+
+	if(UseDarkBackground()){
+		ms_colourTop.r = 50;
+		ms_colourTop.g = 50;
+		ms_colourTop.b = 50;
+		ms_colourTop.a = 255;
+		if(gbShowCollisionPolys){
+			if(CTimer::GetFrameCounter() & 1){
+				ms_colourTop.r = 0;
+				ms_colourTop.g = 0;
+				ms_colourTop.b = 0;
+			}else{
+				ms_colourTop.r = 255;
+				ms_colourTop.g = 255;
+				ms_colourTop.b = 255;
+			}
+		}
+		ms_colourBottom = ms_colourTop;
+		CRect r(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+		CSprite2d::DrawRect(r, ms_colourBottom, ms_colourBottom, ms_colourTop, ms_colourTop);
+	}else{
+		ms_horizonZ = CSprite::CalcHorizonCoors();
+
+		// Draw top/bottom gradient
+		float gradheight = SCREEN_HEIGHT/2.0f;
+		float topedge = ms_horizonZ - gradheight;
+		float botpos, toppos;
+		if(ms_horizonZ > 0.0f && topedge < SCREEN_HEIGHT){
+			ms_colourTop.r = topred;
+			ms_colourTop.g = topgreen;
+			ms_colourTop.b = topblue;
+			ms_colourTop.a = alpha;
+			ms_colourBottom.r = botred;
+			ms_colourBottom.g = botgreen;
+			ms_colourBottom.b = botblue;
+			ms_colourBottom.a = alpha;
+
+			if(ms_horizonZ < SCREEN_HEIGHT)
+				botpos = ms_horizonZ;
+			else{
+				float f = (ms_horizonZ - SCREEN_HEIGHT)/gradheight;
+				ms_colourBottom.r = topred*f + (1.0f-f)*botred;
+				ms_colourBottom.g = topgreen*f + (1.0f-f)*botgreen;
+				ms_colourBottom.b = topblue*f + (1.0f-f)*botblue;
+				botpos = SCREEN_HEIGHT;
+			}
+			if(topedge >= 0.0f)
+				toppos = topedge;
+			else{
+				float f = (0.0f - topedge)/gradheight;
+				ms_colourTop.r = botred*f + (1.0f-f)*topred;
+				ms_colourTop.g = botgreen*f + (1.0f-f)*topgreen;
+				ms_colourTop.b = botblue*f + (1.0f-f)*topblue;
+				toppos = 0.0f;
+			}
+			CSprite2d::DrawRect(CRect(0, toppos, SCREEN_WIDTH, botpos),
+				ms_colourBottom, ms_colourBottom, ms_colourTop, ms_colourTop);
+		}
+
+		// draw the small stripe (whatever it's supposed to be)
+		if(ms_horizonZ > -SMALLSTRIPHEIGHT && ms_horizonZ < SCREEN_HEIGHT){
+			// Same colour as fog
+			ms_colourTop.r = (topred + 2 * botred) / 3;
+			ms_colourTop.g = (topgreen + 2 * botgreen) / 3;
+			ms_colourTop.b = (topblue + 2 * botblue) / 3;
+			CSprite2d::DrawRect(CRect(0, ms_horizonZ, SCREEN_WIDTH, ms_horizonZ+SMALLSTRIPHEIGHT),
+				ms_colourTop, ms_colourTop, ms_colourTop, ms_colourTop);
+		}
+
+		// Only top
+		if(topedge > 0.0f){
+			ms_colourTop.r = topred;
+			ms_colourTop.g = topgreen;
+			ms_colourTop.b = topblue;
+			ms_colourTop.a = alpha;
+			ms_colourBottom.r = topred;
+			ms_colourBottom.g = topgreen;
+			ms_colourBottom.b = topblue;
+			ms_colourBottom.a = alpha;
+
+			botpos = Min(SCREEN_HEIGHT, topedge);
+			CSprite2d::DrawRect(CRect(0, 0, SCREEN_WIDTH, botpos),
+				ms_colourBottom, ms_colourBottom, ms_colourTop, ms_colourTop);
+		}
+
+		// Set both to fog colour for RenderHorizon
+		ms_colourTop.r = (topred + 2 * botred) / 3;
+		ms_colourTop.g = (topgreen + 2 * botgreen) / 3;
+		ms_colourTop.b = (topblue + 2 * botblue) / 3;
+		ms_colourBottom.r = (topred + 2 * botred) / 3;
+		ms_colourBottom.g = (topgreen + 2 * botgreen) / 3;
+		ms_colourBottom.b = (topblue + 2 * botblue) / 3;
+	}
+
+	POP_RENDERGROUP();
+}
+
+void
+CClouds::RenderHorizon(void)
+{
+	if(UseDarkBackground())
+		return;
+
+	ms_colourBottom.a = 230;
+	ms_colourTop.a = 80;
+
+	if(ms_horizonZ > SCREEN_HEIGHT)
+		return;
+
+	PUSH_RENDERGROUP("CClouds::RenderHorizon");
+
+	float z1 = Min(ms_horizonZ + SMALLSTRIPHEIGHT, SCREEN_HEIGHT);
+	CSprite2d::DrawRectXLU(CRect(0, ms_horizonZ, SCREEN_WIDTH, z1),
+		ms_colourBottom, ms_colourBottom, ms_colourTop, ms_colourTop);
+
+	// This is just weird
+	float a = SCREEN_HEIGHT/400.0f * HORIZSTRIPHEIGHT +
+		SCREEN_HEIGHT/300.0f * Max(TheCamera.GetPosition().z, 0.0f);
+	float b = TheCamera.GetUp().z < 0.0f ?
+		SCREEN_HEIGHT :
+		SCREEN_HEIGHT * Abs(TheCamera.GetRight().z);
+	float z2 = z1 + (a + b)*TheCamera.LODDistMultiplier;
+	z2 = Min(z2, SCREEN_HEIGHT);
+	CSprite2d::DrawRect(CRect(0, z1, SCREEN_WIDTH, z2),
+		ms_colourBottom, ms_colourBottom, ms_colourTop, ms_colourTop);
+
+	POP_RENDERGROUP();
+}
diff --git a/src/renderer/Clouds.h b/src/renderer/Clouds.h
new file mode 100644
index 00000000..4d8cd2c8
--- /dev/null
+++ b/src/renderer/Clouds.h
@@ -0,0 +1,21 @@
+#pragma once
+
+class CClouds
+{
+public:
+	static float CloudRotation;
+	static uint32 IndividualRotation;
+
+	static float ms_cameraRoll;
+	static float ms_horizonZ;
+	static CRGBA ms_colourTop;
+	static CRGBA ms_colourBottom;
+
+	static void Init(void);
+	static void Shutdown(void);
+	static void Update(void);
+	static void Render(void);
+	static void RenderBackground(int16 topred, int16 topgreen, int16 topblue,
+		int16 botred, int16 botgreen, int16 botblue, int16 alpha);
+	static void RenderHorizon(void);
+};
diff --git a/src/renderer/Console.cpp b/src/renderer/Console.cpp
new file mode 100644
index 00000000..8ea5b7a3
--- /dev/null
+++ b/src/renderer/Console.cpp
@@ -0,0 +1,96 @@
+#include "common.h"
+#include <stdarg.h>
+
+#include "Console.h"
+#include "Font.h"
+#include "Timer.h"
+
+#define CONSOLE_X_POS (30.0f)
+#define CONSOLE_Y_POS (10.0f)
+#define CONSOLE_LINE_HEIGHT (12.0f)
+
+CConsole TheConsole;
+
+void
+CConsole::AddLine(char *s, uint8 r, uint8 g, uint8 b)
+{
+	char tempstr[MAX_STR_LEN+1];
+
+	while (strlen(s) > MAX_STR_LEN) {
+		strncpy(tempstr, s, MAX_STR_LEN);
+		tempstr[MAX_STR_LEN-1] = '\0';
+		s += MAX_STR_LEN - 1;
+		AddOneLine(tempstr, r, g, b);
+	}
+	AddOneLine(s, r, g, b);
+}
+
+void
+CConsole::AddOneLine(char *s, uint8 r, uint8 g, uint8 b)
+{
+	int32 StrIndex = (m_nLineCount + m_nCurrentLine) % MAX_LINES;
+
+	for (int32 i = 0; i < MAX_STR_LEN; i++) {
+		Buffers[StrIndex][i] = s[i];
+		if (s[i] == '\0') break;
+	}
+
+	uint8 _strNum1 = m_nLineCount;
+	if (_strNum1 < MAX_LINES)
+		_strNum1++;
+
+	m_aTimer[StrIndex] = CTimer::GetTimeInMilliseconds();
+	Buffers[StrIndex][MAX_STR_LEN-1] = '\0';
+	m_aRed[StrIndex] = r;
+	m_aGreen[StrIndex] = g;
+	m_aBlue[StrIndex] = b;
+
+	if (_strNum1 >= MAX_LINES)
+		m_nCurrentLine = (m_nCurrentLine + 1) % MAX_LINES;
+	else
+		m_nLineCount = _strNum1;
+
+}
+
+void
+CConsole::Display()
+{
+	CFont::SetPropOn();
+	CFont::SetBackgroundOff();
+	CFont::SetScale(0.6f, 0.6f); 
+	CFont::SetCentreOff();
+	CFont::SetRightJustifyOff();
+	CFont::SetJustifyOn();
+	CFont::SetRightJustifyWrap(0.0f);
+	CFont::SetBackGroundOnlyTextOff();
+	CFont::SetFontStyle(FONT_BANK);
+#ifndef FIX_BUGS
+	CFont::SetPropOff(); // not sure why this is here anyway
+#endif
+	CFont::SetWrapx(RsGlobal.width);
+
+	while (m_nLineCount != 0 && CTimer::GetTimeInMilliseconds() - m_aTimer[m_nCurrentLine] > 20000) {
+		m_nLineCount--;
+		m_nCurrentLine = (m_nCurrentLine + 1) % MAX_LINES;
+	}
+
+	for (int16 i = 0; i < m_nLineCount; i++) {
+		int16 line = (i + m_nCurrentLine) % MAX_LINES;
+		CFont::SetColor(CRGBA(0, 0, 0, 200));
+		CFont::PrintString(CONSOLE_X_POS + 1.0f, CONSOLE_Y_POS + 1.0f + i * CONSOLE_LINE_HEIGHT, Buffers[line]);
+		CFont::SetColor(CRGBA(m_aRed[line], m_aGreen[line], m_aBlue[line], 200));
+		CFont::PrintString(CONSOLE_X_POS, CONSOLE_Y_POS + i * CONSOLE_LINE_HEIGHT, Buffers[line]);
+	}
+}
+
+void
+cprintf(char* format, ...)
+{
+	char s[256];
+	va_list vl1, vl2;
+
+	va_start(vl1, format);
+	va_copy(vl2, vl1);
+	vsprintf(s, format, vl1);
+	TheConsole.AddLine(s, 255, 255, 128);
+}
diff --git a/src/renderer/Console.h b/src/renderer/Console.h
new file mode 100644
index 00000000..9f22236f
--- /dev/null
+++ b/src/renderer/Console.h
@@ -0,0 +1,27 @@
+#pragma once
+
+class CConsole
+{
+	enum
+	{
+		MAX_LINES = 8, // BUG? only shows 7
+		MAX_STR_LEN = 40,
+	};
+
+	uint8 m_nLineCount;
+	uint8 m_nCurrentLine;
+	wchar Buffers[MAX_LINES][MAX_STR_LEN];
+	uint32 m_aTimer[MAX_LINES];
+	uint8 m_aRed[MAX_LINES];
+	uint8 m_aGreen[MAX_LINES];
+	uint8 m_aBlue[MAX_LINES];
+public:
+	void AddLine(char *s, uint8 r, uint8 g, uint8 b);
+	void AddOneLine(char *s, uint8 r, uint8 g, uint8 b);
+	void Display();
+	void Init() { m_nCurrentLine = 0; m_nLineCount = 0; }
+};
+
+extern CConsole TheConsole;
+
+void cprintf(char*, ...);
\ No newline at end of file
diff --git a/src/renderer/Coronas.cpp b/src/renderer/Coronas.cpp
new file mode 100644
index 00000000..e9f9e662
--- /dev/null
+++ b/src/renderer/Coronas.cpp
@@ -0,0 +1,779 @@
+#include "common.h"
+
+#include "main.h"
+#include "General.h"
+#include "Entity.h"
+#include "TxdStore.h"
+#include "Camera.h"
+#include "Sprite.h"
+#include "Timer.h"
+#include "World.h"
+#include "Weather.h"
+#include "Collision.h"
+#include "Timecycle.h"
+#include "Coronas.h"
+#include "PointLights.h"
+#include "Shadows.h"
+#include "Clock.h"
+#include "Bridge.h"
+
+struct FlareDef
+{
+	float position;
+	float size;
+	int16 red;
+	int16 green;
+	int16 blue;
+	int16 alpha;
+	int16 texture;
+};
+
+FlareDef SunFlareDef[] = {
+	{ -0.5f, 15.0f, 50, 50, 0, 200, 1 },
+	{ -1.0f, 10.0f, 50, 20, 0, 200, 2 },
+	{ -1.5f, 15.0f, 50, 0, 0, 200, 3 },
+	{ -2.5f, 25.0f, 50, 0, 0, 200, 1 },
+	{ 0.5f, 12.5f, 40, 40, 25, 200, 1 },
+	{ 0.05f, 20.0f, 30, 22, 9, 200, 2 },
+	{ 1.3f, 7.5f, 50, 30, 9, 200, 3 },
+	{ 0.0f, 0.0f, 255, 255, 255, 255, 0 }
+};
+
+FlareDef HeadLightsFlareDef[] = {
+	{ -0.5f, 15.5, 70, 70, 70, 200, 1 },
+	{ -1.0f, 10.0, 70, 70, 70, 200, 2 },
+	{ -1.5f, 5.5f, 50, 50, 50, 200, 3 },
+	{ 0.5f, 12.0f, 50, 50, 50, 200, 1 },
+	{ 0.05f, 20.0f, 40, 40, 40, 200, 2 },
+	{ 1.3f, 8.0f, 60, 60, 60, 200, 3 },
+	{ -2.0f, 12.0f, 50, 50, 50, 200, 1 },
+	{ -2.3f, 15.0f, 40, 40, 40, 200, 2 },
+	{ -3.0f, 16.0f, 40, 40, 40, 200, 3 },
+	{ 0.0f, 0.0f, 255, 255, 255, 255, 0 }
+};
+
+
+RwTexture *gpCoronaTexture[9] = { nil, nil, nil, nil, nil, nil, nil, nil, nil };
+
+float CCoronas::LightsMult = 1.0f;
+float CCoronas::SunScreenX;
+float CCoronas::SunScreenY;
+bool CCoronas::bSmallMoon;
+bool CCoronas::SunBlockedByClouds;
+int CCoronas::bChangeBrightnessImmediately;
+
+CRegisteredCorona CCoronas::aCoronas[NUMCORONAS];
+
+const char aCoronaSpriteNames[][32] = {
+	"coronastar",
+	"corona",
+	"coronamoon",
+	"coronareflect",
+	"coronaheadlightline",
+	"coronahex",
+	"coronacircle",
+	"coronaringa",
+	"streek"
+};
+
+void
+CCoronas::Init(void)
+{
+	int i;
+
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(CTxdStore::FindTxdSlot("particle"));
+
+	for(i = 0; i < 9; i++)
+		if(gpCoronaTexture[i] == nil)
+			gpCoronaTexture[i] = RwTextureRead(aCoronaSpriteNames[i], nil);
+
+	CTxdStore::PopCurrentTxd();
+
+	for(i = 0; i < NUMCORONAS; i++)
+		aCoronas[i].id = 0;
+}
+
+void
+CCoronas::Shutdown(void)
+{
+	int i;
+	for(i = 0; i < 9; i++)
+		if(gpCoronaTexture[i]){
+			RwTextureDestroy(gpCoronaTexture[i]);
+			gpCoronaTexture[i] = nil;
+		}
+}
+
+void
+CCoronas::Update(void)
+{
+	int i;
+	static int LastCamLook = 0;
+
+	LightsMult = Min(LightsMult + 0.03f * CTimer::GetTimeStep(), 1.0f);
+
+	int CamLook = 0;
+	if(TheCamera.Cams[TheCamera.ActiveCam].LookingLeft) CamLook |= 1;
+	if(TheCamera.Cams[TheCamera.ActiveCam].LookingRight) CamLook |= 2;
+	if(TheCamera.Cams[TheCamera.ActiveCam].LookingBehind) CamLook |= 4;
+	// BUG?
+	if(TheCamera.GetLookDirection() == LOOKING_BEHIND) CamLook |= 8;
+
+	if(LastCamLook != CamLook)
+		bChangeBrightnessImmediately = 3;
+	else
+		bChangeBrightnessImmediately = Max(bChangeBrightnessImmediately-1, 0);
+	LastCamLook = CamLook;
+
+	for(i = 0; i < NUMCORONAS; i++)
+		if(aCoronas[i].id != 0)
+			aCoronas[i].Update();
+}
+
+void
+CCoronas::RegisterCorona(uint32 id, uint8 red, uint8 green, uint8 blue, uint8 alpha,
+	const CVector &coors, float size, float drawDist, RwTexture *tex,
+	int8 flareType, uint8 reflection, uint8 LOScheck, uint8 drawStreak, float someAngle)
+{
+	int i;
+
+	if(sq(drawDist) < (TheCamera.GetPosition() - coors).MagnitudeSqr2D())
+		return;
+
+	for(i = 0; i < NUMCORONAS; i++)
+		if(aCoronas[i].id == id)
+			break;
+
+	if(i == NUMCORONAS){
+		// add a new one
+
+		// find empty slot
+		for(i = 0; i < NUMCORONAS; i++)
+			if(aCoronas[i].id == 0)
+				break;
+		if(i == NUMCORONAS)
+			return;		// no space
+
+		aCoronas[i].fadeAlpha = 0;
+		aCoronas[i].offScreen = true;
+		aCoronas[i].firstUpdate = true;
+		aCoronas[i].renderReflection = false;
+		aCoronas[i].lastLOScheck = 0;
+		aCoronas[i].sightClear = false;
+		aCoronas[i].hasValue[0] = false;
+		aCoronas[i].hasValue[1] = false;
+		aCoronas[i].hasValue[2] = false;
+		aCoronas[i].hasValue[3] = false;
+		aCoronas[i].hasValue[4] = false;
+		aCoronas[i].hasValue[5] = false;
+
+	}else{
+		// use existing one
+
+		if(aCoronas[i].fadeAlpha == 0 && alpha == 0){
+			// unregister
+			aCoronas[i].id = 0;
+			return;
+		}
+	}
+
+	aCoronas[i].id = id;
+	aCoronas[i].red = red;
+	aCoronas[i].green = green;
+	aCoronas[i].blue = blue;
+	aCoronas[i].alpha = alpha;
+	aCoronas[i].coors = coors;
+	aCoronas[i].size = size;
+	aCoronas[i].someAngle = someAngle;
+	aCoronas[i].registeredThisFrame = true;
+	aCoronas[i].drawDist = drawDist;
+	aCoronas[i].texture = tex;
+	aCoronas[i].flareType = flareType;
+	aCoronas[i].reflection = reflection;
+	aCoronas[i].LOScheck = LOScheck;
+	aCoronas[i].drawStreak = drawStreak;
+}
+
+void
+CCoronas::RegisterCorona(uint32 id, uint8 red, uint8 green, uint8 blue, uint8 alpha,
+		const CVector &coors, float size, float drawDist, uint8 type,
+		int8 flareType, uint8 reflection, uint8 LOScheck, uint8 drawStreak, float someAngle)
+{
+	RegisterCorona(id, red, green, blue, alpha, coors, size, drawDist,
+		gpCoronaTexture[type], flareType, reflection, LOScheck, drawStreak, someAngle);
+}
+
+void
+CCoronas::UpdateCoronaCoors(uint32 id, const CVector &coors, float drawDist, float someAngle)
+{
+	int i;
+
+	if(sq(drawDist) < (TheCamera.GetPosition() - coors).MagnitudeSqr2D())
+		return;
+
+	for(i = 0; i < NUMCORONAS; i++)
+		if(aCoronas[i].id == id)
+			break;
+
+	if(i == NUMCORONAS)
+		return;
+
+	if(aCoronas[i].fadeAlpha == 0)
+		aCoronas[i].id = 0;	// faded out, remove
+	else{
+		aCoronas[i].coors = coors;
+		aCoronas[i].someAngle = someAngle;
+	}
+}
+
+static RwIm2DVertex vertexbufferX[2];
+
+void
+CCoronas::Render(void)
+{
+	int i, j;
+	int screenw, screenh;
+
+	PUSH_RENDERGROUP("CCoronas::Render");
+
+	screenw = RwRasterGetWidth(RwCameraGetRaster(Scene.camera));
+	screenh = RwRasterGetHeight(RwCameraGetRaster(Scene.camera));
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+
+	for(i = 0; i < NUMCORONAS; i++){
+		for(j = 5; j > 0; j--){
+			aCoronas[i].prevX[j] = aCoronas[i].prevX[j-1];
+			aCoronas[i].prevY[j] = aCoronas[i].prevY[j-1];
+			aCoronas[i].prevRed[j] = aCoronas[i].prevRed[j-1];
+			aCoronas[i].prevGreen[j] = aCoronas[i].prevGreen[j-1];
+			aCoronas[i].prevBlue[j] = aCoronas[i].prevBlue[j-1];
+			aCoronas[i].hasValue[j] = aCoronas[i].hasValue[j-1];
+		}
+		aCoronas[i].hasValue[0] = false;
+
+		if(aCoronas[i].id == 0 ||
+		   aCoronas[i].fadeAlpha == 0 && aCoronas[i].alpha == 0)
+			continue;
+
+		CVector spriteCoors;
+		float spritew, spriteh;
+		if(!CSprite::CalcScreenCoors(aCoronas[i].coors, &spriteCoors, &spritew, &spriteh, true)){
+			aCoronas[i].offScreen = true;
+			aCoronas[i].sightClear = false;
+		}else{
+			aCoronas[i].offScreen = false;
+
+			if(spriteCoors.x < 0.0f || spriteCoors.y < 0.0f ||
+			   spriteCoors.x > screenw || spriteCoors.y > screenh){
+				aCoronas[i].offScreen = true;
+				aCoronas[i].sightClear = false;
+			}else{
+				if(CTimer::GetTimeInMilliseconds() > aCoronas[i].lastLOScheck + 2000){
+					aCoronas[i].lastLOScheck = CTimer::GetTimeInMilliseconds();
+					aCoronas[i].sightClear = CWorld::GetIsLineOfSightClear(
+						aCoronas[i].coors, TheCamera.Cams[TheCamera.ActiveCam].Source,
+						true, true, false, false, false, true, false);
+				}
+			
+				// add new streak point
+				if(aCoronas[i].sightClear){
+					aCoronas[i].prevX[0] = spriteCoors.x;
+					aCoronas[i].prevY[0] = spriteCoors.y;
+					aCoronas[i].prevRed[0] = aCoronas[i].red;
+					aCoronas[i].prevGreen[0] = aCoronas[i].green;
+					aCoronas[i].prevBlue[0] = aCoronas[i].blue;
+					aCoronas[i].hasValue[0] = true;
+				}
+			
+				// if distance too big, break streak
+				if(aCoronas[i].hasValue[1]){
+					if(Abs(aCoronas[i].prevX[0] - aCoronas[i].prevX[1]) > 50.0f ||
+					   Abs(aCoronas[i].prevY[0] - aCoronas[i].prevY[1]) > 50.0f)
+						aCoronas[i].hasValue[0] = false;
+				}
+			}
+
+
+			if(aCoronas[i].fadeAlpha && spriteCoors.z < aCoronas[i].drawDist){
+				float recipz = 1.0f/spriteCoors.z;
+				float fadeDistance = aCoronas[i].drawDist / 2.0f;
+				float distanceFade = spriteCoors.z < fadeDistance ? 1.0f : 1.0f - (spriteCoors.z - fadeDistance)/fadeDistance;
+				int totalFade = aCoronas[i].fadeAlpha * distanceFade;
+
+				if(aCoronas[i].LOScheck)
+					RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+				else
+					RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+
+				// render corona itself
+				if(aCoronas[i].texture){
+					float fogscale = CWeather::Foggyness*Min(spriteCoors.z, 40.0f)/40.0f + 1.0f;
+					if(CCoronas::aCoronas[i].id == SUN_CORE)
+						spriteCoors.z = 0.95f * RwCameraGetFarClipPlane(Scene.camera);
+					RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(aCoronas[i].texture));
+					spriteCoors.z -= 1.5f;
+
+					if(aCoronas[i].texture == gpCoronaTexture[8]){
+						// what's this?
+						float f = 1.0f - aCoronas[i].someAngle*2.0f/PI;
+						float wscale = 6.0f*sq(sq(sq(f))) + 0.5f;
+						float hscale = 0.35f - (wscale - 0.5f) * 0.06f;
+						hscale = Max(hscale, 0.15f);
+
+						CSprite::RenderOneXLUSprite(spriteCoors.x, spriteCoors.y, spriteCoors.z,
+							spritew * aCoronas[i].size * wscale,
+							spriteh * aCoronas[i].size * fogscale * hscale,
+							CCoronas::aCoronas[i].red / fogscale,
+							CCoronas::aCoronas[i].green / fogscale,
+							CCoronas::aCoronas[i].blue / fogscale,
+							totalFade,
+							recipz,
+							255);
+					}else{
+						CSprite::RenderOneXLUSprite_Rotate_Aspect(
+							spriteCoors.x, spriteCoors.y, spriteCoors.z,
+							spritew * aCoronas[i].size * fogscale,
+							spriteh * aCoronas[i].size * fogscale,
+							CCoronas::aCoronas[i].red / fogscale,
+							CCoronas::aCoronas[i].green / fogscale,
+							CCoronas::aCoronas[i].blue / fogscale,
+							totalFade,
+							recipz,
+							20.0f * recipz,
+							255);
+					}
+				}
+
+				// render flares
+				if(aCoronas[i].flareType != FLARE_NONE){
+					FlareDef *flare;
+
+					switch(aCoronas[i].flareType){
+					case FLARE_SUN: flare = SunFlareDef; break;
+					case FLARE_HEADLIGHTS: flare = HeadLightsFlareDef; break;
+					default: assert(0);
+					}
+
+					for(; flare->texture; flare++){
+						RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[flare->texture + 4]));
+						CSprite::RenderOneXLUSprite(
+							(spriteCoors.x - (screenw/2)) * flare->position + (screenw/2),
+							(spriteCoors.y - (screenh/2)) * flare->position + (screenh/2),
+							spriteCoors.z,
+							4.0f*flare->size * spritew/spriteh,
+							4.0f*flare->size,
+							(flare->red * aCoronas[i].red)>>8,
+							(flare->green * aCoronas[i].green)>>8,
+							(flare->blue * aCoronas[i].blue)>>8,
+							(totalFade * flare->alpha)>>8,
+							recipz, 255);
+					}
+				}
+			}
+		}
+	}
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+
+	// streaks
+	for(i = 0; i < NUMCORONAS; i++){
+		if(aCoronas[i].id == 0 || !aCoronas[i].drawStreak)
+			continue;
+
+		for(j = 0; j < 5; j++){
+			if(!aCoronas[i].hasValue[j] || !aCoronas[i].hasValue[j+1])
+				continue;
+
+			int alpha1 = (float)(6 - j) / 6 * 128;
+			int alpha2 = (float)(6 - (j+1)) / 6 * 128;
+
+			RwIm2DVertexSetScreenX(&vertexbufferX[0], aCoronas[i].prevX[j]);
+			RwIm2DVertexSetScreenY(&vertexbufferX[0], aCoronas[i].prevY[j]);
+			RwIm2DVertexSetIntRGBA(&vertexbufferX[0], aCoronas[i].prevRed[j] * alpha1 / 256, aCoronas[i].prevGreen[j] * alpha1 / 256, aCoronas[i].prevBlue[j] * alpha1 / 256, 255);
+			RwIm2DVertexSetScreenX(&vertexbufferX[1], aCoronas[i].prevX[j+1]);
+			RwIm2DVertexSetScreenY(&vertexbufferX[1], aCoronas[i].prevY[j+1]);
+			RwIm2DVertexSetIntRGBA(&vertexbufferX[1], aCoronas[i].prevRed[j+1] * alpha2 / 256, aCoronas[i].prevGreen[j+1] * alpha2 / 256, aCoronas[i].prevBlue[j+1] * alpha2 / 256, 255);
+
+#ifdef FIX_BUGS
+			RwIm2DVertexSetScreenZ(&vertexbufferX[0], RwIm2DGetNearScreenZ());
+			RwIm2DVertexSetCameraZ(&vertexbufferX[0], RwCameraGetNearClipPlane(Scene.camera));
+			RwIm2DVertexSetRecipCameraZ(&vertexbufferX[0], 1.0f/RwCameraGetNearClipPlane(Scene.camera));
+			RwIm2DVertexSetScreenZ(&vertexbufferX[1], RwIm2DGetNearScreenZ());
+			RwIm2DVertexSetCameraZ(&vertexbufferX[1], RwCameraGetNearClipPlane(Scene.camera));
+			RwIm2DVertexSetRecipCameraZ(&vertexbufferX[1], 1.0f/RwCameraGetNearClipPlane(Scene.camera));
+#endif
+
+			RwIm2DRenderLine(vertexbufferX, 2, 0, 1);
+		}
+	}
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+
+	POP_RENDERGROUP();
+}
+
+void
+CCoronas::RenderReflections(void)
+{
+	int i;
+	CColPoint point;
+	CEntity *entity;
+
+	if(CWeather::WetRoads > 0.0f){
+		PUSH_RENDERGROUP("CCoronas::RenderReflections");
+
+#ifdef FIX_BUGS
+		CSprite::InitSpriteBuffer();
+#endif
+
+		RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpCoronaTexture[3]));
+
+		for(i = 0; i < NUMCORONAS; i++){
+			if(aCoronas[i].id == 0 ||
+			   aCoronas[i].fadeAlpha == 0 && aCoronas[i].alpha == 0 ||
+			   aCoronas[i].reflection == 0)
+				continue;
+
+			// check if we want a reflection on this corona
+			if(aCoronas[i].renderReflection){
+				if(((CTimer::GetFrameCounter() + i) & 0xF) == 0 &&
+				   CWorld::ProcessVerticalLine(aCoronas[i].coors, -1000.0f, point, entity, true, false, false, false, true, false, nil))
+					aCoronas[i].heightAboveRoad = aCoronas[i].coors.z - point.point.z;
+			}else{
+				if(CWorld::ProcessVerticalLine(aCoronas[i].coors, -1000.0f, point, entity, true, false, false, false, true, false, nil)){
+					aCoronas[i].heightAboveRoad = aCoronas[i].coors.z - point.point.z;
+					aCoronas[i].renderReflection = true;
+				}
+			}
+
+			// Don't draw if reflection is too high
+			if(aCoronas[i].renderReflection && aCoronas[i].heightAboveRoad < 20.0f){
+				// don't draw if camera is below road
+				if(CCoronas::aCoronas[i].coors.z - aCoronas[i].heightAboveRoad > TheCamera.GetPosition().z)
+					continue;
+
+				CVector coors = aCoronas[i].coors;
+				coors.z -= 2.0f*aCoronas[i].heightAboveRoad;
+
+				CVector spriteCoors;
+				float spritew, spriteh;
+				if(CSprite::CalcScreenCoors(coors, &spriteCoors, &spritew, &spriteh, true)){
+					float drawDist = 0.75f * aCoronas[i].drawDist;
+					drawDist = Min(drawDist, 55.0f);
+					if(spriteCoors.z < drawDist){
+						float fadeDistance = drawDist / 2.0f;
+						float distanceFade = spriteCoors.z < fadeDistance ? 1.0f : 1.0f - (spriteCoors.z - fadeDistance)/fadeDistance;
+						distanceFade = Clamp(distanceFade, 0.0f, 1.0f);
+						float recipz = 1.0f/RwCameraGetNearClipPlane(Scene.camera);
+						float heightFade = (20.0f - aCoronas[i].heightAboveRoad)/20.0f;
+						int intensity = distanceFade*heightFade * 230.0 * CWeather::WetRoads;
+
+						CSprite::RenderBufferedOneXLUSprite(
+#ifdef FIX_BUGS
+							spriteCoors.x, spriteCoors.y, spriteCoors.z,
+#else
+							spriteCoors.x, spriteCoors.y, RwIm2DGetNearScreenZ(),
+#endif
+							spritew * aCoronas[i].size * 0.75f,
+							spriteh * aCoronas[i].size * 2.0f,
+							(intensity * CCoronas::aCoronas[i].red)>>8,
+							(intensity * CCoronas::aCoronas[i].green)>>8,
+							(intensity * CCoronas::aCoronas[i].blue)>>8,
+							255,
+							recipz,
+							255);
+					}
+				}
+			}
+		}
+		CSprite::FlushSpriteBuffer();
+
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+
+		POP_RENDERGROUP();
+	}else{
+		for(i = 0; i < NUMCORONAS; i++)
+			aCoronas[i].renderReflection = false;
+	}
+}
+
+void 
+CCoronas::DoSunAndMoon(void)
+{
+	// yeah, moon is done somewhere else....
+
+	CVector sunCoors = CTimeCycle::GetSunDirection();
+	sunCoors *= 150.0f;
+	sunCoors += TheCamera.GetPosition();
+
+	if(CTimeCycle::GetSunDirection().z > -0.2f){
+		float size = ((CGeneral::GetRandomNumber()&0xFF) * 0.005f + 10.0f) * CTimeCycle::GetSunSize();
+		RegisterCorona(SUN_CORE,
+			CTimeCycle::GetSunCoreRed(), CTimeCycle::GetSunCoreGreen(), CTimeCycle::GetSunCoreBlue(),
+			255, sunCoors, size,
+			999999.88f, TYPE_STAR, FLARE_NONE, REFLECTION_OFF, LOSCHECK_OFF, STREAK_OFF, 0.0f);
+
+		if(CTimeCycle::GetSunDirection().z > 0.0f)
+			RegisterCorona(SUN_CORONA,
+				CTimeCycle::GetSunCoronaRed(), CTimeCycle::GetSunCoronaGreen(), CTimeCycle::GetSunCoronaBlue(),
+				255, sunCoors, 25.0f * CTimeCycle::GetSunSize(),
+				999999.88f, TYPE_STAR, FLARE_SUN, REFLECTION_OFF, LOSCHECK_ON, STREAK_OFF, 0.0f);
+	}
+
+	CVector spriteCoors;
+	float spritew, spriteh;
+	if(CSprite::CalcScreenCoors(sunCoors, &spriteCoors, &spritew, &spriteh, true)){
+		SunScreenX = spriteCoors.x;
+		SunScreenY = spriteCoors.y;
+	}else{
+		SunScreenX = 1000000.0f;
+		SunScreenY = 1000000.0f;
+	}
+}
+
+void
+CRegisteredCorona::Update(void)
+{
+	if(!registeredThisFrame)
+		alpha = 0;
+
+	if(LOScheck &&
+	   (CCoronas::SunBlockedByClouds && id == CCoronas::SUN_CORONA ||
+	    !CWorld::GetIsLineOfSightClear(coors, TheCamera.GetPosition(), true, false, false, false, false, false))){
+		// Corona is blocked, fade out
+		fadeAlpha = Max(fadeAlpha - 15.0f*CTimer::GetTimeStep(), 0.0f);
+	}else if(offScreen){
+		// Same when off screen
+		fadeAlpha = Max(fadeAlpha - 15.0f*CTimer::GetTimeStep(), 0.0f);
+	}else{
+		// Visible
+		if(alpha > fadeAlpha){
+			// fade in
+			fadeAlpha = Min(fadeAlpha + 15.0f*CTimer::GetTimeStep(), alpha);
+			if(CCoronas::bChangeBrightnessImmediately)
+				fadeAlpha = alpha;
+		}else if(alpha < fadeAlpha){
+			// too visible, decrease alpha but not below alpha
+			fadeAlpha = Max(fadeAlpha - 15.0f*CTimer::GetTimeStep(), alpha);
+		}
+
+		// darken scene when the sun is visible
+		if(id == CCoronas::SUN_CORONA)
+			CCoronas::LightsMult = Max(CCoronas::LightsMult - CTimer::GetTimeStep()*0.06f, 0.6f);
+	}
+
+	// remove if invisible
+	if(fadeAlpha == 0 && !firstUpdate)
+		id = 0;
+	firstUpdate = false;
+	registeredThisFrame = false;
+}
+
+void
+CEntity::ProcessLightsForEntity(void)
+{
+	int i, n;
+	C2dEffect *effect;
+	CVector pos;
+	bool lightOn, lightFlickering;
+	uint32 flashTimer1, flashTimer2, flashTimer3;
+
+	if(bRenderDamaged || !bIsVisible || GetUp().z < 0.96f)
+		return;
+
+	flashTimer1 = 0;
+	flashTimer2 = 0;
+	flashTimer3 = 0;
+
+	n = CModelInfo::GetModelInfo(GetModelIndex())->GetNum2dEffects();
+	for(i = 0; i < n; i++, flashTimer1 += 0x80, flashTimer2 += 0x100, flashTimer3 += 0x200){
+		effect = CModelInfo::GetModelInfo(GetModelIndex())->Get2dEffect(i);
+
+		if(effect->type != EFFECT_LIGHT)
+			continue;
+
+		pos = GetMatrix() * effect->pos;
+
+		lightOn = false;
+		lightFlickering = false;
+		switch(effect->light.lightType){
+		case LIGHT_ON:
+			lightOn = true;
+			break;
+		case LIGHT_ON_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7)
+				lightOn = true;
+			break;
+		case LIGHT_FLICKER:
+			if((CTimer::GetTimeInMilliseconds() ^ m_randomSeed) & 0x60)
+				lightOn = true;
+			else
+				lightFlickering = true;
+			if((CTimer::GetTimeInMilliseconds()>>11 ^ m_randomSeed) & 3)
+				lightOn = true;
+			break;
+		case LIGHT_FLICKER_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7 || CWeather::WetRoads > 0.5f){
+				if((CTimer::GetTimeInMilliseconds() ^ m_randomSeed) & 0x60)
+					lightOn = true;
+				else
+					lightFlickering = true;
+				if((CTimer::GetTimeInMilliseconds()>>11 ^ m_randomSeed) & 3)
+					lightOn = true;
+			}
+			break;
+		case LIGHT_FLASH1:
+			if((CTimer::GetTimeInMilliseconds() + flashTimer1) & 0x200)
+				lightOn = true;
+			break;
+		case LIGHT_FLASH1_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7)
+				if((CTimer::GetTimeInMilliseconds() + flashTimer1) & 0x200)
+					lightOn = true;
+			break;
+		case LIGHT_FLASH2:
+			if((CTimer::GetTimeInMilliseconds() + flashTimer2) & 0x400)
+				lightOn = true;
+			break;
+		case LIGHT_FLASH2_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7)
+				if((CTimer::GetTimeInMilliseconds() + flashTimer2) & 0x400)
+					lightOn = true;
+			break;
+		case LIGHT_FLASH3:
+			if((CTimer::GetTimeInMilliseconds() + flashTimer3) & 0x800)
+				lightOn = true;
+			break;
+		case LIGHT_FLASH3_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7)
+				if((CTimer::GetTimeInMilliseconds() + flashTimer3) & 0x800)
+					lightOn = true;
+			break;
+		case LIGHT_RANDOM_FLICKER:
+			if(m_randomSeed > 16)
+				lightOn = true;
+			else{
+				if((CTimer::GetTimeInMilliseconds() ^ m_randomSeed*8) & 0x60)
+					lightOn = true;
+				else
+					lightFlickering = true;
+				if((CTimer::GetTimeInMilliseconds()>>11 ^ m_randomSeed*8) & 3)
+					lightOn = true;
+			}
+			break;
+		case LIGHT_RANDOM_FLICKER_NIGHT:
+			if(CClock::GetHours() > 18 || CClock::GetHours() < 7){
+				if(m_randomSeed > 16)
+					lightOn = true;
+				else{
+					if((CTimer::GetTimeInMilliseconds() ^ m_randomSeed*8) & 0x60)
+						lightOn = true;
+					else
+						lightFlickering = true;
+					if((CTimer::GetTimeInMilliseconds()>>11 ^ m_randomSeed*8) & 3)
+						lightOn = true;
+				}
+			}
+			break;
+		case LIGHT_BRIDGE_FLASH1:
+			if(CBridge::ShouldLightsBeFlashing() && CTimer::GetTimeInMilliseconds() & 0x200)
+				lightOn = true;
+			break;
+		case LIGHT_BRIDGE_FLASH2:
+			if(CBridge::ShouldLightsBeFlashing() && (CTimer::GetTimeInMilliseconds() & 0x1FF) < 60)
+				lightOn = true;
+			break;
+		}
+
+		// Corona
+		if(lightOn)
+			CCoronas::RegisterCorona((uintptr)this + i,
+				effect->col.r, effect->col.g, effect->col.b, 255,
+				pos, effect->light.size, effect->light.dist,
+				effect->light.corona, effect->light.flareType, effect->light.roadReflection,
+				effect->light.flags&LIGHTFLAG_LOSCHECK, CCoronas::STREAK_OFF, 0.0f);
+		else if(lightFlickering)
+			CCoronas::RegisterCorona((uintptr)this + i,
+				0, 0, 0, 255,
+				pos, effect->light.size, effect->light.dist,
+				effect->light.corona, effect->light.flareType, effect->light.roadReflection,
+				effect->light.flags&LIGHTFLAG_LOSCHECK, CCoronas::STREAK_OFF, 0.0f);
+
+		// Pointlight
+		if(effect->light.flags & LIGHTFLAG_FOG_ALWAYS){
+			CPointLights::AddLight(CPointLights::LIGHT_FOGONLY_ALWAYS,
+				pos, CVector(0.0f, 0.0f, 0.0f),
+				effect->light.range,
+				effect->col.r/255.0f, effect->col.g/255.0f, effect->col.b/255.0f,
+				CPointLights::FOG_ALWAYS, true);
+		}else if(effect->light.flags & LIGHTFLAG_FOG_NORMAL && lightOn && effect->light.range == 0.0f){
+			CPointLights::AddLight(CPointLights::LIGHT_FOGONLY,
+				pos, CVector(0.0f, 0.0f, 0.0f),
+				effect->light.range,
+				effect->col.r/255.0f, effect->col.g/255.0f, effect->col.b/255.0f,
+				CPointLights::FOG_NORMAL, true);
+		}else if(lightOn && effect->light.range != 0.0f){
+			if(effect->col.r == 0 && effect->col.g == 0 && effect->col.b == 0){
+				CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					pos, CVector(0.0f, 0.0f, 0.0f),
+					effect->light.range,
+					0.0f, 0.0f, 0.0f,
+					CPointLights::FOG_NONE, true);
+			}else{
+				CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					pos, CVector(0.0f, 0.0f, 0.0f),
+					effect->light.range,
+					effect->col.r*CTimeCycle::GetSpriteBrightness()/255.0f,
+					effect->col.g*CTimeCycle::GetSpriteBrightness()/255.0f,
+					effect->col.b*CTimeCycle::GetSpriteBrightness()/255.0f,
+					// half-useless because LIGHTFLAG_FOG_ALWAYS can't be on
+					(effect->light.flags & LIGHTFLAG_FOG) >> 1,
+					true);
+			}
+		}
+
+		// Light shadow
+		if(effect->light.shadowSize != 0.0f){
+			if(lightOn){
+				CShadows::StoreStaticShadow((uintptr)this + i, SHADOWTYPE_ADDITIVE,
+					effect->light.shadow, &pos,
+					effect->light.shadowSize, 0.0f,
+					0.0f, -effect->light.shadowSize,
+					128,
+					effect->col.r*CTimeCycle::GetSpriteBrightness()*effect->light.shadowIntensity/255.0f,
+					effect->col.g*CTimeCycle::GetSpriteBrightness()*effect->light.shadowIntensity/255.0f,
+					effect->col.b*CTimeCycle::GetSpriteBrightness()*effect->light.shadowIntensity/255.0f,
+					15.0f, 1.0f, 40.0f, false, 0.0f);
+			}else if(lightFlickering){
+				CShadows::StoreStaticShadow((uintptr)this + i, SHADOWTYPE_ADDITIVE,
+					effect->light.shadow, &pos,
+					effect->light.shadowSize, 0.0f,
+					0.0f, -effect->light.shadowSize,
+					0, 0.0f, 0.0f, 0.0f,
+					15.0f, 1.0f, 40.0f, false, 0.0f);
+			}
+		}
+	}
+}
diff --git a/src/renderer/Coronas.h b/src/renderer/Coronas.h
new file mode 100644
index 00000000..46eb4315
--- /dev/null
+++ b/src/renderer/Coronas.h
@@ -0,0 +1,101 @@
+#pragma once
+
+extern RwTexture *gpCoronaTexture[9];
+
+struct CRegisteredCorona
+{
+	uint32 id;
+	uint32 lastLOScheck;
+	RwTexture *texture;
+	uint8 red;
+	uint8 green;
+	uint8 blue;
+	uint8 alpha;		// alpha when fully visible
+	uint8 fadeAlpha;	// actual value used for rendering, faded
+	CVector coors;
+	float size;
+	float someAngle;
+	bool registeredThisFrame;
+	float drawDist;
+	int8 flareType;
+	int8 reflection;
+
+	uint8 LOScheck : 1;
+	uint8 offScreen : 1;
+	uint8 firstUpdate : 1;
+	uint8 drawStreak : 1;
+	uint8 sightClear : 1;
+
+	bool renderReflection;
+	float heightAboveRoad;
+
+	float prevX[6];
+	float prevY[6];
+	uint8 prevRed[6];
+	uint8 prevGreen[6];
+	uint8 prevBlue[6];
+	bool hasValue[6];
+
+	void Update(void);
+};
+
+VALIDATE_SIZE(CRegisteredCorona, 0x80);
+
+class CCoronas
+{
+	static CRegisteredCorona aCoronas[NUMCORONAS];
+public:
+	enum {
+		SUN_CORE = 1,
+		SUN_CORONA
+	};
+	enum {
+		TYPE_STAR,
+		TYPE_NORMAL,
+		TYPE_MOON,
+		TYPE_REFLECT,
+		TYPE_HEADLIGHT,
+		TYPE_HEX,
+		TYPE_CIRCLE,
+		TYPE_RING,
+		TYPE_STREAK,
+	};
+	enum {
+		FLARE_NONE,
+		FLARE_SUN,
+		FLARE_HEADLIGHTS
+	};
+	enum {
+		REFLECTION_OFF,
+		REFLECTION_ON,
+	};
+	enum {
+		LOSCHECK_OFF,
+		LOSCHECK_ON,
+	};
+	enum {
+		STREAK_OFF,
+		STREAK_ON,
+	};
+
+	static float LightsMult;
+	static float SunScreenY;
+	static float SunScreenX;
+	static bool bSmallMoon;
+	static bool SunBlockedByClouds;
+	static int bChangeBrightnessImmediately;
+
+	static void Init(void);
+	static void Shutdown(void);
+	static void Update(void);
+	static void RegisterCorona(uint32 id, uint8 red, uint8 green, uint8 blue, uint8 alpha,
+		const CVector &coors, float size, float drawDist, RwTexture *tex,
+		int8 flareType, uint8 reflection, uint8 LOScheck, uint8 drawStreak, float someAngle);
+	static void RegisterCorona(uint32 id, uint8 red, uint8 green, uint8 blue, uint8 alpha,
+		const CVector &coors, float size, float drawDist, uint8 type,
+		int8 flareType, uint8 reflection, uint8 LOScheck, uint8 drawStreak, float someAngle);
+	static void UpdateCoronaCoors(uint32 id, const CVector &coors, float drawDist, float someAngle);
+	static void Render(void);
+	static void RenderReflections(void);
+	static void DoSunAndMoon(void);
+};
diff --git a/src/renderer/Credits.cpp b/src/renderer/Credits.cpp
new file mode 100644
index 00000000..60581793
--- /dev/null
+++ b/src/renderer/Credits.cpp
@@ -0,0 +1,518 @@
+#include "common.h"
+
+#include "Timer.h"
+#include "Font.h"
+#include "Frontend.h"
+#include "RwHelper.h"
+#include "Camera.h"
+#include "Text.h"
+#include "Credits.h"
+
+bool CCredits::bCreditsGoing;
+uint32 CCredits::CreditsStartTime;
+
+void
+CCredits::Init(void)
+{
+	Stop();
+}
+
+void
+CCredits::Start(void)
+{
+	bCreditsGoing = true;
+	CreditsStartTime = CTimer::GetTimeInMilliseconds();
+}
+
+void
+CCredits::Stop(void)
+{
+	bCreditsGoing = false;
+}
+
+void
+CCredits::PrintCreditSpace(float space, uint32 &line)
+{
+	line += space * 25.0f;
+}
+
+void
+CCredits::PrintCreditText(float scaleX, float scaleY, wchar *text, uint32 &lineoffset, float scrolloffset)
+{
+#ifdef FIX_BUGS
+	float start = DEFAULT_SCREEN_HEIGHT + 50.0f;
+#else
+	float start = SCREEN_HEIGHT + 50.0f;
+#endif
+	float y = lineoffset + start - scrolloffset;
+	if(y > -50.0f && y < start){
+#ifdef FIX_BUGS
+		CFont::SetScale(SCREEN_SCALE_X(scaleX), SCREEN_SCALE_Y(scaleY));
+		CFont::PrintString(SCREEN_WIDTH/2.0f, SCREEN_SCALE_Y(y), (uint16*)text);
+#else
+		CFont::SetScale(scaleX, scaleY);
+		CFont::PrintString(SCREEN_WIDTH/2.0f, y, (uint16*)text);
+#endif
+	}
+	lineoffset += scaleY*25.0f;
+}
+
+void
+CCredits::Render(void)
+{
+	uint32 lineoffset;
+	float scrolloffset;
+
+	if(!bCreditsGoing || FrontEndMenuManager.m_bMenuActive)
+		return;
+
+	DefinedState();
+	lineoffset = 0;
+	scrolloffset = (CTimer::GetTimeInMilliseconds() - CreditsStartTime) / 24.0f;
+	CFont::SetJustifyOff();
+	CFont::SetBackgroundOff();
+#ifdef FIX_BUGS
+	CFont::SetCentreSize(SCREEN_SCALE_X(DEFAULT_SCREEN_WIDTH - 20));
+#else
+	CFont::SetCentreSize(SCREEN_WIDTH - 20);
+#endif
+	CFont::SetCentreOn();
+	CFont::SetPropOn();
+	CFont::SetColor(CRGBA(220, 220, 220, 220));
+	CFont::SetFontStyle(FONT_HEADING);
+
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED002"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED003"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED004"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED005"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED006"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED007"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED008"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED009"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED010"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED011"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED012"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED013"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED014"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED015"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED016"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED017"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED018"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED019"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED020"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED021"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED022"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED245"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED023"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED024"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED025"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED026"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED027"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED028"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED257"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED029"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED030"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED031"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED032"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED033"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED244"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED034"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED035"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED247"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED036"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED037"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED038"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED039"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED040"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED041"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED042"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED043"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED044"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED045"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED046"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED047"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED048"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED049"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED050"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRD050A"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED051"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED052"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED053"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED054"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED055"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED056"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED248"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED249"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED250"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED251"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED252"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED253"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED057"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED058"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED059"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED254"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED255"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED060"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED061"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED062"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED063"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED064"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED065"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED066"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED067"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED068"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED069"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED070"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED071"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED072"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED073"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED074"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED075"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED076"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED077"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED078"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED079"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED080"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED081"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED082"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED083"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED084"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED242"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED259"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED260"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED261"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED262"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED085"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED086"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED087"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED088"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED089"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED090"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED091"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED094"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED095"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED096"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED097"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED098"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED099"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED263"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED264"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED265"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED267"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED270"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED266"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED100"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED101"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED102"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED103"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED104"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED105"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED106"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED268"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED269"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED107"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED108"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED109"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED110"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED111"), lineoffset, scrolloffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED112"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED113"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED114"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED115"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED116"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED117"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED118"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED119"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED120"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED121"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED122"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED123"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED124"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED125"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED126"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED127"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED128"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED129"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED130"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED131"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED132"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED133"), lineoffset, scrolloffset);
+	if(CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_ITALIAN)
+	        PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED134"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED135"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED136"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD136A"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED137"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD137A"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED138"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD138A"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD138B"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED139"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.7f, 1.0f, TheText.Get("CRED140"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD140A"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD140B"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD140C"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD140D"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD140E"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED141"), lineoffset, scrolloffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED142"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED143"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditText(1.0f, 1.0f, TheText.Get("CRED144"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED145"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED146"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED147"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED148"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED149"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED150"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED151"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED152"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED153"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED154"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED155"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED156"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED157"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED158"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED159"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED160"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED161"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED162"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED163"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED164"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED165"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED166"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED167"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED168"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED169"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED170"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED171"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED172"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED173"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED174"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED175"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED176"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED177"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED178"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED179"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED180"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED181"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED182"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED183"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED184"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED185"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED186"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED187"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED188"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED189"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED190"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED191"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED192"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED193"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED194"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED195"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED196"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED197"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED198"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED199"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED200"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED201"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED202"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED203"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED204"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED205"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED206"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED207"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED208"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED209"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED210"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED211"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED212"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED213"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED214"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED215"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED216"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED241"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED217"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED218"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD218A"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRD218B"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED219"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED220"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED221"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED222"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED223"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED224"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED225"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED226"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED227"), lineoffset, scrolloffset);
+	PrintCreditSpace(1.5f, lineoffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED228"), lineoffset, scrolloffset);
+	PrintCreditText(1.7f, 1.7f, TheText.Get("CRED229"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditText(1.4f, 0.82f, TheText.Get("CRED230"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED231"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED232"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED233"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED234"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED235"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED236"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED237"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED238"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED239"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED240"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("LITTLE"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("NICK"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED243"), lineoffset, scrolloffset);
+	PrintCreditText(1.4f, 1.4f, TheText.Get("CRED244"), lineoffset, scrolloffset);
+	PrintCreditSpace(2.0f, lineoffset);
+	PrintCreditSpace(2.0f, lineoffset);
+
+
+	CFont::DrawFonts();
+	if(TheCamera.m_WideScreenOn)
+		TheCamera.DrawBordersForWideScreen();
+
+#ifdef FIX_BUGS
+	if(lineoffset + DEFAULT_SCREEN_HEIGHT - scrolloffset < -10.0f)
+#else
+	if(lineoffset + SCREEN_HEIGHT - scrolloffset < -10.0f)
+#endif
+	{
+		bCreditsGoing = false;
+	}
+}
+
+bool CCredits::AreCreditsDone(void)
+{
+	return !bCreditsGoing;
+}
diff --git a/src/renderer/Credits.h b/src/renderer/Credits.h
new file mode 100644
index 00000000..e049ce76
--- /dev/null
+++ b/src/renderer/Credits.h
@@ -0,0 +1,15 @@
+#pragma once
+
+class CCredits
+{
+	static bool bCreditsGoing;
+	static uint32 CreditsStartTime;
+public:
+	static void Init(void);
+	static void Start(void);
+	static void Stop(void);
+	static bool AreCreditsDone(void);
+	static void Render(void);
+	static void PrintCreditSpace(float space, uint32 &line);
+	static void PrintCreditText(float scaleX, float scaleY, wchar *text, uint32 &lineoffset, float scrolloffset);
+};
diff --git a/src/renderer/Draw.cpp b/src/renderer/Draw.cpp
new file mode 100644
index 00000000..f702f188
--- /dev/null
+++ b/src/renderer/Draw.cpp
@@ -0,0 +1,95 @@
+#include "common.h"
+
+#include "Draw.h"
+#include "Frontend.h"
+#include "Camera.h"
+#include "CutsceneMgr.h"
+
+#ifdef ASPECT_RATIO_SCALE
+float CDraw::ms_fAspectRatio = DEFAULT_ASPECT_RATIO;
+float CDraw::ms_fScaledFOV = 45.0f;
+#endif
+
+float CDraw::ms_fNearClipZ;
+float CDraw::ms_fFarClipZ;
+float CDraw::ms_fFOV = 45.0f;
+float CDraw::ms_fLODDistance;
+
+uint8 CDraw::FadeValue;
+uint8 CDraw::FadeRed;
+uint8 CDraw::FadeGreen;
+uint8 CDraw::FadeBlue;
+
+#ifdef PROPER_SCALING	
+bool CDraw::ms_bProperScaling = true;
+#endif
+#ifdef  FIX_RADAR
+bool CDraw::ms_bFixRadar = true;	
+#endif
+#ifdef FIX_SPRITES
+bool CDraw::ms_bFixSprites = true;	
+#endif
+
+float
+CDraw::FindAspectRatio(void)
+{
+#ifndef ASPECT_RATIO_SCALE
+	if(FrontEndMenuManager.m_PrefsUseWideScreen)	
+		return 16.0f/9.0f;
+	else
+		return 4.0f/3.0f;
+#else
+	switch (FrontEndMenuManager.m_PrefsUseWideScreen) {
+	case AR_AUTO:
+		return SCREEN_WIDTH / SCREEN_HEIGHT;
+	default:
+	case AR_4_3:
+		return 4.0f / 3.0f;
+	case AR_5_4:
+		return 5.0f / 4.0f;
+	case AR_16_10:
+		return 16.0f / 10.0f;
+	case AR_16_9:
+		return 16.0f / 9.0f;
+	case AR_21_9:
+		return 21.0f / 9.0f;
+	};
+#endif
+}
+
+#ifdef ASPECT_RATIO_SCALE
+// convert a 4:3 hFOV to vFOV,
+// then convert that vFOV to hFOV for our aspect ratio,
+// i.e. HOR+
+float
+CDraw::ConvertFOV(float hfov)
+{
+	// => tan(hFOV/2) = tan(vFOV/2)*aspectRatio
+	// => tan(vFOV/2) = tan(hFOV/2)/aspectRatio
+	float ar1 = DEFAULT_ASPECT_RATIO;
+	float ar2 = GetAspectRatio();
+	hfov = DEGTORAD(hfov);
+	float vfov = Atan(tan(hfov/2) / ar1) *2;
+	hfov = Atan(tan(vfov/2) * ar2) *2;
+	return RADTODEG(hfov);
+}
+#endif
+
+void
+CDraw::SetFOV(float fov)
+{
+#ifdef ASPECT_RATIO_SCALE
+	if (!CCutsceneMgr::IsRunning())
+		ms_fScaledFOV = ConvertFOV(fov);
+	else
+		ms_fScaledFOV = fov;
+#endif
+	ms_fFOV = fov;
+}
+
+#ifdef PROPER_SCALING	
+float CDraw::ScaleY(float y)
+{
+	return ms_bProperScaling ? y : y * ((float)DEFAULT_SCREEN_HEIGHT/SCREEN_HEIGHT_NTSC);
+}
+#endif 
\ No newline at end of file
diff --git a/src/renderer/Draw.h b/src/renderer/Draw.h
new file mode 100644
index 00000000..8727e0e0
--- /dev/null
+++ b/src/renderer/Draw.h
@@ -0,0 +1,73 @@
+#pragma once
+
+enum eAspectRatio 
+{
+	// Make sure these work the same as FrontEndMenuManager.m_PrefsUseWideScreen
+	// without widescreen support
+	AR_AUTO,
+	AR_4_3,
+	AR_5_4,
+	AR_16_10,
+	AR_16_9,
+	AR_21_9,
+	
+	AR_MAX,
+};
+
+class CDraw
+{
+private:
+	static float ms_fNearClipZ;
+	static float ms_fFarClipZ;
+	static float ms_fFOV;
+#ifdef ASPECT_RATIO_SCALE
+	// we use this variable to scale a lot of 2D elements
+	// so better cache it
+	static float ms_fAspectRatio;
+	// similar thing for 3D rendering
+	static float ms_fScaledFOV;
+#endif
+public:
+	static float ms_fLODDistance;	// set but unused?
+
+	static uint8 FadeValue;
+	static uint8 FadeRed;
+	static uint8 FadeGreen;
+	static uint8 FadeBlue;
+	
+#ifdef PROPER_SCALING	
+	static bool ms_bProperScaling;
+#endif
+#ifdef FIX_RADAR
+	static bool ms_bFixRadar;	
+#endif
+#ifdef FIX_SPRITES
+	static bool ms_bFixSprites;	
+#endif
+
+	static void SetNearClipZ(float nearclip) { ms_fNearClipZ = nearclip; }
+	static float GetNearClipZ(void) { return ms_fNearClipZ; }
+	static void SetFarClipZ(float farclip) { ms_fFarClipZ = farclip; }
+	static float GetFarClipZ(void) { return ms_fFarClipZ; }
+
+	static void SetFOV(float fov);
+	static float GetFOV(void) { return ms_fFOV; }
+#ifdef ASPECT_RATIO_SCALE
+	static float GetScaledFOV(void) { return ms_fScaledFOV; }
+#else
+	static float GetScaledFOV(void) { return ms_fFOV; }
+#endif
+
+	static float FindAspectRatio(void);
+#ifdef ASPECT_RATIO_SCALE
+	static float ConvertFOV(float fov);
+	static float GetAspectRatio(void) { return ms_fAspectRatio; }
+	static void SetAspectRatio(float ratio) { ms_fAspectRatio = ratio; }
+#else
+	static float GetAspectRatio(void) { return FindAspectRatio(); }
+#endif
+	
+#ifdef PROPER_SCALING	
+	static float ScaleY(float y);
+#endif 
+};
diff --git a/src/renderer/Fluff.cpp b/src/renderer/Fluff.cpp
new file mode 100644
index 00000000..c4cfe7f7
--- /dev/null
+++ b/src/renderer/Fluff.cpp
@@ -0,0 +1,870 @@
+#include "common.h"
+#include "main.h"
+
+#include "Entity.h"
+#include "Fluff.h"
+#include "Camera.h"
+#include "Sprite.h"
+#include "Coronas.h"
+#include "General.h"
+#include "Timer.h"
+#include "Clock.h"
+#include "Weather.h"
+#include "Stats.h"
+#include "maths.h"
+#include "Frontend.h"
+
+uint8 ScrollCharSet[59][5] = {
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // ' '
+	{ 0x00, 0x00, 0x1D, 0x00, 0x00 }, // '!'
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // '"'
+	{ 0x0A, 0x1F, 0x0A, 0x1F, 0x0A }, // '#'
+	{ 0x00, 0x09, 0x1F, 0x12, 0x00 }, // '$'
+	{ 0x18, 0x18, 0x00, 0x03, 0x03 }, // '%'
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // '&'
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // '''
+	{ 0x01, 0x02, 0x04, 0x08, 0x10 }, // '('
+	{ 0x00, 0x00, 0x18, 0x00, 0x00 }, // ')'
+	{ 0x15, 0x04, 0x1F, 0x04, 0x15 }, // '*'
+	{ 0x00, 0x04, 0x0E, 0x04, 0x00 }, // '+'
+	{ 0x00, 0x00, 0x03, 0x00, 0x00 }, // ','
+	{ 0x00, 0x04, 0x04, 0x04, 0x00 }, // '-'
+	{ 0x00, 0x00, 0x01, 0x00, 0x00 }, // '.'
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // '/'
+	{ 0x0E, 0x11, 0x11, 0x11, 0x0E }, // '0'
+	{ 0x01, 0x09, 0x1F, 0x01, 0x01 }, // '1'
+	{ 0x03, 0x15, 0x15, 0x15, 0x09 }, // '2'
+	{ 0x11, 0x11, 0x15, 0x15, 0x0A }, // '3'
+	{ 0x02, 0x06, 0x0A, 0x1F, 0x02 }, // '4'
+	{ 0x1D, 0x15, 0x15, 0x15, 0x12 }, // '5'
+	{ 0x0E, 0x15, 0x15, 0x15, 0x12 }, // '6'
+	{ 0x18, 0x10, 0x13, 0x14, 0x18 }, // '7'
+	{ 0x0A, 0x15, 0x15, 0x15, 0x0A }, // '8'
+	{ 0x08, 0x15, 0x15, 0x15, 0x0E }, // '9'
+	{ 0x00, 0x00, 0x0A, 0x00, 0x00 }, // ':'
+	{ 0x18, 0x18, 0x00, 0x03, 0x03 }, // ';'
+	{ 0x04, 0x08, 0x1F, 0x08, 0x04 }, // '<'
+	{ 0x00, 0x0A, 0x0A, 0x0A, 0x00 }, // '='
+	{ 0x04, 0x02, 0x1F, 0x02, 0x04 }, // '>'
+	{ 0x10, 0x10, 0x15, 0x14, 0x1D }, // '?'
+	{ 0x00, 0x1C, 0x14, 0x1C, 0x00 }, // '@'
+	{ 0x0F, 0x12, 0x12, 0x12, 0x0F }, // 'A'
+	{ 0x1F, 0x15, 0x15, 0x15, 0x0A }, // 'B'
+	{ 0x0E, 0x11, 0x11, 0x11, 0x0A }, // 'C'
+	{ 0x1F, 0x11, 0x11, 0x11, 0x0E }, // 'D'
+	{ 0x1F, 0x15, 0x15, 0x11, 0x11 }, // 'E'
+	{ 0x1F, 0x14, 0x14, 0x10, 0x10 }, // 'F'
+	{ 0x0E, 0x11, 0x15, 0x15, 0x06 }, // 'G'
+	{ 0x1F, 0x04, 0x04, 0x04, 0x1F }, // 'H'
+	{ 0x11, 0x11, 0x1F, 0x11, 0x11 }, // 'I'
+	{ 0x02, 0x01, 0x01, 0x01, 0x1E }, // 'J'
+	{ 0x1F, 0x04, 0x0C, 0x12, 0x01 }, // 'K'
+	{ 0x1F, 0x01, 0x01, 0x01, 0x01 }, // 'L'
+	{ 0x1F, 0x08, 0x06, 0x08, 0x1F }, // 'M'
+	{ 0x1F, 0x08, 0x04, 0x02, 0x1F }, // 'N'
+	{ 0x0E, 0x11, 0x11, 0x11, 0x0E }, // 'O'
+	{ 0x1F, 0x12, 0x12, 0x12, 0x0C }, // 'P'
+	{ 0x0C, 0x12, 0x12, 0x13, 0x0D }, // 'Q'
+	{ 0x1F, 0x14, 0x14, 0x16, 0x09 }, // 'R'
+	{ 0x09, 0x15, 0x15, 0x15, 0x02 }, // 'S'
+	{ 0x10, 0x10, 0x1F, 0x10, 0x10 }, // 'T'
+	{ 0x1E, 0x01, 0x01, 0x01, 0x1E }, // 'U'
+	{ 0x1C, 0x02, 0x01, 0x02, 0x1C }, // 'V'
+	{ 0x1E, 0x01, 0x06, 0x01, 0x1E }, // 'W'
+	{ 0x11, 0x0A, 0x04, 0x0A, 0x11 }, // 'X'
+	{ 0x18, 0x04, 0x03, 0x04, 0x18 }, // 'Y'
+	{ 0x11, 0x13, 0x15, 0x19, 0x11 }  // 'Z'
+};
+
+// ---------- CMovingThings ----------
+enum eScrollBarTypes
+{
+	SCROLL_BUSINESS,
+	SCROLL_TRAFFIC,
+	SCROLL_ENTERTAINMENT,
+	SCROLL_AIRPORT_DOORS,
+	SCROLL_AIRPORT_FRONT,
+	SCROLL_STORE,
+	SCROLL_USED_CARS
+};
+
+CScrollBar    aScrollBars[11];
+CTowerClock   aTowerClocks[2];
+CDigitalClock aDigitalClocks[3];
+
+CMovingThing CMovingThings::StartCloseList;
+CMovingThing CMovingThings::EndCloseList;
+int16 CMovingThings::Num;
+CMovingThing CMovingThings::aMovingThings[NUMMOVINGTHINGS];
+ 
+void CMovingThings::Init()
+{
+	StartCloseList.m_pNext = &CMovingThings::EndCloseList;
+	StartCloseList.m_pPrev = nil;
+	EndCloseList.m_pNext = nil;
+	EndCloseList.m_pPrev = &CMovingThings::StartCloseList;
+	Num = 0;
+	
+	// Initialize scroll bars
+	 aScrollBars[0].Init(CVector(  228.3f,    -669.0f,     39.0f  ), SCROLL_BUSINESS,       0.0f,     0.5f,     0.5f,   255, 128, 0,   0.3f);
+	 aScrollBars[1].Init(CVector(  772.0f,     164.0f,     -9.5f  ), SCROLL_TRAFFIC,        0.0f,     0.5f,     0.25f,  128, 255, 0,   0.3f);
+	 aScrollBars[2].Init(CVector(-1089.61f,   -584.224f,   13.246f), SCROLL_AIRPORT_DOORS,  0.0f,    -0.1706f,  0.107f, 255, 0,   0,   0.11f);
+	 aScrollBars[3].Init(CVector(-1089.61f,   -602.04602f, 13.246f), SCROLL_AIRPORT_DOORS,  0.0f,    -0.1706f,  0.107f, 0,   255, 0,   0.11f);
+	 aScrollBars[4].Init(CVector(-1089.61f,   -619.81702f, 13.246f), SCROLL_AIRPORT_DOORS,  0.0f,    -0.1706f,  0.107f, 255, 128, 0,   0.11f);
+	 aScrollBars[5].Init(CVector(-754.578f,   -633.50897f, 18.411f), SCROLL_AIRPORT_FRONT,  0.0f,     0.591f,   0.52f,  100, 100, 255, 0.3f);
+	 aScrollBars[6].Init(CVector( -754.578f,  -586.672f,   18.411f), SCROLL_AIRPORT_FRONT,  0.0f,     0.591f,   0.52f,  100, 100, 255, 0.3f);
+	 aScrollBars[7].Init(CVector(   85.473f, -1069.512f,   30.5f  ), SCROLL_STORE,          0.625f,  -0.3125f,  0.727f, 100, 100, 255, 0.5f);
+	 aScrollBars[8].Init(CVector(   74.823f, -1086.879f,   31.495f), SCROLL_ENTERTAINMENT, -0.2083f,  0.1041f,  0.5f,   255, 255, 128, 0.3f);
+	 aScrollBars[9].Init(CVector(  -36.459f, -1031.2371f,  32.534f), SCROLL_ENTERTAINMENT, -0.1442f,  0.0721f,  0.229f, 150, 255, 50,  0.3f);
+	aScrollBars[10].Init(CVector( 1208.0f,     -62.208f,   19.157f), SCROLL_USED_CARS,      0.0642f, -0.20365f, 0.229f, 255, 128, 0,   0.3f);
+
+	// Initialize tower clocks
+	aTowerClocks[0].Init(CVector(59.4f, -1081.3f, 54.15f), -1.0f,  0.0f, 0, 0, 0, 80.0f, 2.0f);
+	aTowerClocks[1].Init(CVector(55.4f, -1083.6f, 54.15f),  0.0f, -1.0f, 0, 0, 0, 80.0f, 2.0f);
+
+	// Initialize digital clocks
+	CVector2D sz(3.7f, 2.144f);
+	sz.Normalise();
+	aDigitalClocks[0].Init(
+		CVector(54.485f - sz.x * 0.05f + sz.y * 0.3f, -1081.679f - sz.y * 0.05f - sz.x * 0.3f, 32.803f),
+		sz.y, -sz.x, 255, 0, 0, 100.0f, 0.8f
+	);
+	aDigitalClocks[1].Init(
+		CVector(60.564f + sz.x * 0.05f - sz.y * 0.3f, -1083.089f + sz.y * 0.05f + sz.x * 0.3f, 32.803f),
+		-sz.y, sz.x, 0, 0, 255, 100.0f, 0.8f
+	);
+	aDigitalClocks[2].Init(
+		CVector(58.145f - sz.y * 0.05f - sz.x * 0.3f, -1079.268f + sz.x * 0.05f - sz.y * 0.3f, 32.803f),
+		-sz.x, -sz.y, 0, 255, 0, 100.0f, 0.8f
+	);
+}
+
+void CMovingThings::Shutdown()
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(aScrollBars); ++i)
+		aScrollBars[i].SetVisibility(false);
+	for (i = 0; i < ARRAY_SIZE(aTowerClocks); ++i)
+		aTowerClocks[i].SetVisibility(false);
+	for (i = 0; i < ARRAY_SIZE(aDigitalClocks); ++i)
+		aDigitalClocks[i].SetVisibility(false);
+}
+
+void CMovingThings::Update()
+{
+	int16 i;
+#ifndef SQUEEZE_PERFORMANCE
+	const int TIME_SPAN = 64; // frames to process all aMovingThings
+
+	int block = CTimer::GetFrameCounter() % TIME_SPAN;
+
+	for (i = (block * NUMMOVINGTHINGS) / TIME_SPAN; i < ((block + 1) * NUMMOVINGTHINGS) / TIME_SPAN; i++) {
+		if (aMovingThings[i].m_nHidden == 1)
+			aMovingThings[i].Update();
+	}
+
+	for (i = 0; i < CMovingThings::Num; i++) {
+		if (aMovingThings[i].m_nHidden == 0)
+			aMovingThings[i].Update();
+	}
+#endif
+
+	for (i = 0; i < ARRAY_SIZE(aScrollBars); ++i)
+	{
+		if (aScrollBars[i].IsVisible() || (CTimer::GetFrameCounter() + i) % 8 == 0)
+			aScrollBars[i].Update();
+	}
+	for (i = 0; i < ARRAY_SIZE(aTowerClocks); ++i)
+	{
+		if (aTowerClocks[i].IsVisible() || (CTimer::GetFrameCounter() + i) % 8 == 0)
+			aTowerClocks[i].Update();
+	}
+	for (i = 0; i < ARRAY_SIZE(aDigitalClocks); ++i)
+	{
+		if (aDigitalClocks[i].IsVisible() || (CTimer::GetFrameCounter() + i) % 8 == 0)
+			aDigitalClocks[i].Update();
+	}
+}
+
+void CMovingThings::Render()
+{
+	int i;
+	PUSH_RENDERGROUP("CMovingThings::Render");
+	for (i = 0; i < ARRAY_SIZE(aScrollBars); ++i)
+	{
+		if (aScrollBars[i].IsVisible())
+			aScrollBars[i].Render();
+	}
+	for (i = 0; i < ARRAY_SIZE(aTowerClocks); ++i)
+	{
+		if (aTowerClocks[i].IsVisible())
+			aTowerClocks[i].Render();
+	}
+	for (i = 0; i < ARRAY_SIZE(aDigitalClocks); ++i)
+	{
+		if (aDigitalClocks[i].IsVisible())
+			aDigitalClocks[i].Render();
+	}
+	POP_RENDERGROUP();
+}
+
+// ---------- CMovingThing ----------
+void CMovingThing::Update()
+{
+	m_pEntity->GetMatrix().UpdateRW();
+	m_pEntity->UpdateRwFrame();
+	
+	if (SQR(m_pEntity->GetPosition().x - TheCamera.GetPosition().x) + SQR(m_pEntity->GetPosition().y - TheCamera.GetPosition().y) < 40000.0f) {
+		if (m_nHidden == 1) {
+			AddToList(&CMovingThings::StartCloseList);
+			m_nHidden = 0;
+		}
+	} else {
+		if (m_nHidden == 0) {
+			RemoveFromList();
+			m_nHidden = 1;
+		}
+	}
+}
+
+void CMovingThing::AddToList(CMovingThing *pThing)
+{
+	m_pNext = pThing->m_pNext;
+	m_pPrev = pThing;
+	pThing->m_pNext = this;
+	m_pNext->m_pPrev = this;
+}
+
+void CMovingThing::RemoveFromList()
+{
+	m_pNext->m_pPrev = m_pPrev;
+	m_pPrev->m_pNext = m_pNext;
+}
+
+int16 CMovingThing::SizeList()
+{
+	CMovingThing *next = m_pNext;
+	int16 count = 0;
+
+	while (next != nil) {
+		next = next->m_pNext;
+		count++;
+	}
+
+	return count;
+}
+
+// ---------- Find message functions ----------
+const char* FindTunnelMessage()
+{
+	if (CStats::CommercialPassed)
+		return "LIBERTY TUNNEL HAS BEEN OPENED TO ALL TRAFFIC . . .   ";
+
+	if (CStats::IndustrialPassed)
+		return "FIRST PHASE LIBERTY TUNNEL HAS BEEN COMPLETED . . .   ";
+
+	return "FIRST PHASE LIBERTY TUNNEL ABOUT TO BE COMPLETED . . .   ";
+}
+
+const char* FindBridgeMessage()
+{
+	if (CStats::CommercialPassed)
+		return "STAUNTON LIFT BRIDGE IS OPERATIONAL AGAIN    ";
+
+	if (CStats::IndustrialPassed)
+		return "LONG DELAYS BEHIND US AS CALLAHAN BRIDGE IS FIXED . . .   STAUNTON LIFT BRIDGE STUCK OPEN   ";
+
+	return "CHAOS AS CALLAHAN BRIDGE IS UNDER REPAIR. . .   ";
+}
+
+char String_Time[] = "THE TIME IS 12:34    ";
+const char* FindTimeMessage()
+{
+	String_Time[12] = '0' + CClock::GetHours() / 10;
+	String_Time[13] = '0' + CClock::GetHours() % 10;
+	String_Time[15] = '0' + CClock::GetMinutes() / 10;
+	String_Time[16] = '0' + CClock::GetMinutes() % 10;
+	return String_Time;
+}
+
+char String_DigitalClock[] = "12:34";
+const char* FindDigitalClockMessage()
+{
+	if (((CTimer::GetTimeInMilliseconds() >> 10) & 7) < 6)
+	{
+		String_DigitalClock[0] = '0' + CClock::GetHours() / 10;
+		String_DigitalClock[1] = '0' + CClock::GetHours() % 10;
+		String_DigitalClock[2] = CTimer::GetTimeInMilliseconds() & 0x200 ? ':' : ' ';
+		String_DigitalClock[3] = '0' + CClock::GetMinutes() / 10;
+		String_DigitalClock[4] = '0' + CClock::GetMinutes() % 10;
+	}
+	else
+	{
+		// they didn't use rad2deg here because of 3.14
+		int temperature = 13.0f - 6.0f * Cos((CClock::GetMinutes() + 60.0f * CClock::GetHours()) / (4.0f * 180.0f / 3.14f) - 1.0f);
+		String_DigitalClock[0] = '0' + temperature / 10;
+		if (String_DigitalClock[0] == '0')
+			String_DigitalClock[0] = ' ';
+		String_DigitalClock[1] = '0' + temperature % 10;
+		String_DigitalClock[2] = ' ';
+		String_DigitalClock[3] = '@';
+		String_DigitalClock[4] = 'C';
+	}
+	return String_DigitalClock;
+}
+
+// ---------- CScrollBar ----------
+void CScrollBar::Init(CVector position, uint8 type, float sizeX, float sizeY, float sizeZ, uint8 red, uint8 green, uint8 blue, float scale)
+{
+	for (int i = 0; i < ARRAY_SIZE(m_MessageBar); ++i)
+		m_MessageBar[i] = 0;
+
+	m_pMessage = ". ";
+	m_MessageCurrentChar = 0;
+	m_MessageLength = 2;
+
+	m_Counter  = 0;
+	m_bVisible = false;
+	m_Position = position;
+	m_Type     = type;
+	m_Size.x   = sizeX;
+	m_Size.y   = sizeY;
+	m_Size.z   = sizeZ;
+	m_uRed     = red;
+	m_uGreen   = green;
+	m_uBlue    = blue;
+	m_fScale   = scale;
+}
+
+void CScrollBar::Update()
+{
+	float distanceFromCamera = (TheCamera.GetPosition() - m_Position).Magnitude();
+	if (distanceFromCamera > 100.0f)
+	{
+		m_bVisible = false;
+		return;
+	}
+
+	m_bVisible = true;
+
+	if (distanceFromCamera < 75.0f)
+		m_fIntensity = 1.0f;
+	else
+		m_fIntensity = 1.0f - 4.0f * (distanceFromCamera - 75.0f) / 100.0f;
+
+	m_Counter = (m_Counter + 1) % 8;
+		
+	// if message is fully printed, load up the next one
+	if (m_Counter == 0 && ++m_MessageCurrentChar >= m_MessageLength)
+	{
+		const char* previousMessage = m_pMessage;
+		switch (m_Type)
+		{
+		case SCROLL_BUSINESS:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 7)
+				{
+				case 0:
+					m_pMessage = "SHARES  UYE<10% DWD<20% NDWE>22% . . .   ";
+					break;
+				case 1:
+					m_pMessage = "CRIME WAVE HITS LIBERTY CITY . . .   ";
+					break;
+				case 2:
+					m_pMessage = "SHARES  OBR>29% MADD<76% LEZ<11% ADAMSKI>53% AAG>110%. . .   ";
+					break;
+				case 3:
+					m_pMessage = FindTunnelMessage();
+					break;
+				case 4:
+					m_pMessage = FindBridgeMessage();
+					break;
+				case 5:
+					m_pMessage = FindTimeMessage();
+					break;
+				case 6:
+					if (CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_FRENCH || CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_GERMAN)
+						m_pMessage = FindTimeMessage();
+					else
+						m_pMessage = "WWW.GRANDTHEFTAUTO3.COM    ";
+					break;
+				}
+			}
+			break;
+		case SCROLL_TRAFFIC:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 8)
+				{
+				case 0:
+					m_pMessage = "DRIVE CAREFULLY . . .   ";
+					break;
+				case 1:
+					m_pMessage = "RECENT WAVE OF CARJACKINGS. KEEP YOUR DOORS LOCKED !!!  ";
+					break;
+				case 2:
+					m_pMessage = "CHECK YOUR SPEED . . .  ";
+					break;
+				case 3:
+					m_pMessage = "KEEP YOUR EYES ON THE ROAD AND NOT ON THIS SIGN  ";
+					break;
+				case 4:
+					if (CWeather::Foggyness > 0.5f)
+						m_pMessage = "POOR VISIBILITY !   ";
+					else if (CWeather::WetRoads > 0.5f)
+						m_pMessage = "ROADS ARE SLIPPERY !   ";
+					else
+						m_pMessage = "ENJOY YOUR TRIP   ";
+					break;
+				case 5:
+					m_pMessage = FindTunnelMessage();
+					break;
+				case 6:
+					m_pMessage = FindBridgeMessage();
+					break;
+				case 7:
+					m_pMessage = FindTimeMessage();
+					break;
+				}
+			}
+			break;
+		case SCROLL_ENTERTAINMENT:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 12)
+				{
+				case 0:
+					m_pMessage = " )69TH STREET) STILL HOLDS TOP POSITION THIS MONTH AT THE BOX-OFFICE WITH )MY FAIR LADYBOY) JUST CREEPING UP BEHIND.   ";
+					break;
+				case 1:
+					m_pMessage = " TALKING OF )FANNIE). THERE IS STILL TIME TO CATCH THIS LOVELY FAMILY MUSICAL, ABOUT THE ORPHAN WHO IS SO EASILY TAKEN IN BY ANY MAN WITH LOADS OF MONEY.  ";
+					break;
+				case 2:
+					m_pMessage = " DO NOT MISS  )GTA3, THE MUSICAL) . . . ";
+					break;
+				case 3:
+					m_pMessage =
+						" STILL RUNNING ARE )RATS) AND )GUYS AND DOGS), BETWEEN THEN THEY SHOULD HAVE THE LEGS TO LAST TILL THE AND OF THE YEAR. . . "
+						" ALSO FOR FOUR LEGGED FANS, THE STAGE VERSION OF THE GRITTY REALISTIC )SATERDAY NIGHT BEAVER) OPENED LAST WEEKEND,"
+						" AND I FOR ONE CERTAINLY ENJOYED THAT.  ";
+					break;
+				case 4:
+					m_pMessage =
+						" NOW SHOWING STATE-WIDE, ARNOLD STEELONE, HOLLYWOODS BEST LIVING SPECIAL EFFECT, APPEARS AGAIN AS A HALF_MAN,"
+						" HALF ANDROID IN THE HALF-BAKED ROMP, )TOP DOWN CITY). AN HOMAGE TO HIS EARLIER TWO MULTI_MILLION MAKING MOVIES,"
+						" IN WHICH HE PLAYED TWO-DEE, AN OUT OF CONTROL MONSTER, INTENT ON CORRUPTING CIVILISATION!   ";
+					break;
+				case 5:
+					m_pMessage =
+						" ALSO APPEARING THIS WEEK )HALF-COCKED) SEES CHUCK SCHWARTZ UP TO HIS USUAL NONSENSE AS HE TAKES ON HALF OF LIBERTY CITY"
+						" IN AN ATTEMPT TO SAVE HIS CROSS-DRESSING LADY-BOY SIDEKICK, )MISS PING-PONG), FROM A GANG OF RUTHLESS COSMETIC SURGEONS.    ";
+					break;
+				case 6:
+					m_pMessage =
+						" STILL SHOWING: )SOLDIERS OF MISFORTUNE), ATTROCIOUS ACTING WHICH SEES BOYZ 2 GIRLZ) TRANSITION FROM THE CHARTS TO THE BIG SCREEN,"
+						" AT LEAST THEY ALL DIE AT THE END. . . ";
+					break;
+				case 7:
+					m_pMessage =
+						" )BADFELLAS) IS STILL GOING STRONG WITH CROWDS ALMOST BEING PUSHED INTO CINEMAS TO SEE THIS ONE."
+						" ANOTHER ONE WORTH LOOKING INTO IS )THE TUNNEL).    ";
+					break;
+				case 8:
+					m_pMessage = FindTunnelMessage();
+					break;
+				case 9:
+					m_pMessage = FindBridgeMessage();
+					break;
+				case 10:
+					m_pMessage = FindTimeMessage();
+					break;
+				case 11:
+					m_pMessage = "WWW.ROCKSTARGAMES.COM    ";
+					break;
+				}
+			}
+			break;
+		case SCROLL_AIRPORT_DOORS:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 4)
+				{
+				case 0:
+					m_pMessage = "WELCOME TO LIBERTY CITY . . .   ";
+					break;
+				case 1:
+					m_pMessage = "PLEASE HAVE YOUR PASSPORT READY . . .   ";
+					break;
+				case 2:
+					m_pMessage = "PLACE KEYS, FIREARMS, CHANGE AND OTHER METAL OBJECTS ON THE TRAY PLEASE . . .  ";
+					break;
+				case 3:
+					m_pMessage = FindTimeMessage();
+					break;
+				}
+			}
+			break;
+		case SCROLL_AIRPORT_FRONT:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 4)
+				{
+				case 0:
+					m_pMessage = "WELCOME TO FRANCIS INTERNATIONAL AIRPORT . . .  ";
+					break;
+				case 1:
+					m_pMessage = "PLEASE DO NOT LEAVE LUGGAGE UNATTENDED . . .  ";
+					break;
+				case 2:
+					m_pMessage = "FOLLOW 1 FOR LONG AND SHORT TERM PARKING  ";
+					break;
+				case 3:
+					m_pMessage = FindTimeMessage();
+					break;
+				}
+			}
+			break;
+		case SCROLL_STORE:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 10)
+				{
+				case 0:
+					m_pMessage = "WWW.ROCKSTARGAMES.COM    ";
+					break;
+				case 1:
+					m_pMessage = "GTA3   OUT NOW . . . ";
+					break;
+				case 2:
+					m_pMessage = "OUR STUFF IS  CHEAP CHEAP CHEAP      ";
+					break;
+				case 3:
+					m_pMessage = "BUY 12 CDS GET ONE FREE . . . ";
+					break;
+				case 4:
+					m_pMessage = "APPEARING IN SHOP SOON, )THE BLOODY CHOPPERS), WITH THEIR NEW ALBUM, )IS THAT MY DAUGHTER?) ";
+					break;
+				case 5:
+					m_pMessage = "THIS MONTH IS OUR CRAZY CLEAROUT MONTH, EVERYTHING MUST GO, CDS, DVDS, STAFF, EVEN OUR CARPETS!    ";
+					break;
+				case 6:
+					m_pMessage =
+						"OUT THIS WEEK: THE THEME TUNE TO )BOYS TO GIRLS) FIRST MOVIE )SOLDIERS OF MISFORTUNE), "
+						"THE SINGLE )LET ME IN YOU)RE BODY-BAG) IS TAKEN FROM THE SOUNDTRACK ALBUM, )BOOT CAMP BOYS). "
+						"ALSO INCLUDES THE SMASH SINGLE, )PRAY IT GOES OK).    ";
+					break;
+				case 7:
+					m_pMessage =
+						"ALBUMS OUT THIS WEEK: MARYDANCING, )MUTHA O) CHRIST), FEATURING THE SINGLE )WASH HIM OFF), "
+						"ALSO CRAIG GRAYS) DEBUT, )FADE AWAY), INCLUDES THE SINGLE OF THE SAME NAME. . . ";
+					break;
+				case 8:
+					m_pMessage =
+						"ON THE FILM FRONT, A NELY COMPILED COMPILATION OF ARNOLD STEELONES GREATEST MOVIES ON DVD. "
+						"THE PACK INCLUDES THE EARLY )BY-CEP), THE CULT CLASSIC )FUTURE ANNHILATOR), AND THE HILARIOUS CROSS-DRESSING COMEDY )SISTERS). "
+						"ONE FOR ALL THE FAMILY. . . ";
+					break;
+				case 9:
+					m_pMessage = FindTimeMessage();
+					break;
+				}
+			}
+			break;
+		case SCROLL_USED_CARS:
+			while (previousMessage == m_pMessage)
+			{
+				switch (CGeneral::GetRandomNumber() % 11)
+				{
+				case 0:
+					m_pMessage = "QUICK, TAKE A LOOK AT OUR CURRENT STOCK )CAUSE THESE AUTOS ARE MOVIN) FAST . . .  ";
+					break;
+				case 1:
+					m_pMessage = "THAT)S RIGHT, HERE AT )CAPITAL AUTO SALES) OUR VEHICLES ARE SO GOOD THAT THEY PRACTICALLY DRIVE THEMSELVES OFF OUR LOT . . .   ";
+					break;
+				case 2:
+					m_pMessage = "EASY CREDIT ON ALL CARS . . .   ";
+					break;
+				case 3:
+					m_pMessage = "FEEL LIKE A STUD IN ONE OF OUR STALLIONS OR TEST-DRIVE OUR BANSHEE, IT)S A REAL STEAL!!!   ";
+					break;
+				case 4:
+					m_pMessage = "TRY OUR HARDY PERENNIAL, IT)LL LAST YOU THE WHOLE YEAR. OUR BOBCATS AIN)T NO PUSSIES EITHER!!!   ";
+					break;
+				case 5:
+					m_pMessage = "IF IT)S A GUARANTEE YOU'RE AFTER, GO SOMEWHERE ELSE, )CAPITAL) CARS ARE THAT GOOD THEY DON)T NEED GUARANTEES!!!   ";
+					break;
+				case 6:
+					m_pMessage = "TOP DOLLAR OFFERED FOR YOUR OLD WHEELS, NOT YOUR CAR, JUST IT)S WHEELS. . .   ";
+					break;
+				case 7:
+					m_pMessage = "THAT)S RIGHT WE)RE CAR SILLY. TEST DRIVE ANY CAR, YOU WON)T WANT TO BRING IT BACK!!!   ";
+					break;
+				case 8:
+					m_pMessage = "FREE FLUFFY DICE WITH ALL PURCHASES. . .";
+					break;
+				case 9:
+					if (CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_FRENCH || CMenuManager::m_PrefsLanguage == CMenuManager::LANGUAGE_GERMAN)
+						m_pMessage = "QUICK, TAKE A LOOK AT OUR CURRENT STOCK )CAUSE THESE AUTOS ARE MOVIN) FAST . . .  ";
+					else
+						m_pMessage = "HTTP:((ROCKSTARGAMES.COM(GRANDTHEFTAUTO3(CAPITALAUTOS    ";
+					break;
+				case 10:
+					m_pMessage = FindTimeMessage();
+					break;
+				}
+			}
+			break;
+		}
+
+		m_MessageLength = (uint32)strlen(m_pMessage);
+		m_MessageCurrentChar = 0;
+	}
+
+	// Scroll
+	for (int i = 0; i < ARRAY_SIZE(m_MessageBar)-1; i++)
+		m_MessageBar[i] = m_MessageBar[i + 1];
+	m_MessageBar[ARRAY_SIZE(m_MessageBar)-1] = m_Counter < 5 ? ScrollCharSet[m_pMessage[m_MessageCurrentChar] - ' '][m_Counter] : 0;
+
+	// Introduce some random displaying glitches; signs aren't supposed to be perfect :P
+	switch (CGeneral::GetRandomNumber() & 0xFF)
+	{
+	case 0x0D: m_MessageBar[ARRAY_SIZE(m_MessageBar)-1] = 0;                 break;
+	case 0xE3: m_MessageBar[ARRAY_SIZE(m_MessageBar)-1] = 0xE3;              break;
+	case 0x64: m_MessageBar[ARRAY_SIZE(m_MessageBar)-1] = ~m_MessageBar[ARRAY_SIZE(m_MessageBar)-1]; break;
+	}
+}
+
+void CScrollBar::Render()
+{
+	if (!TheCamera.IsSphereVisible(m_Position, 2.0f * 20.0f * (ABS(m_Size.x) + ABS(m_Size.y))))
+		return;
+
+	CSprite::InitSpriteBuffer();
+
+	// Calculate intensity of colours
+	uint8 r = m_fIntensity * m_uRed;
+	uint8 g = m_fIntensity * m_uGreen;
+	uint8 b = m_fIntensity * m_uBlue;
+
+	// Set render states
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND,          (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATETEXTUREFILTER,     (void*)rwFILTERLINEAR);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER,     RwTextureGetRaster(gpCoronaTexture[0]));
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void*)TRUE);
+
+	CVector coronaCoord, screenCoord;
+	float screenW, screenH;
+	for (int i = 1; i < ARRAY_SIZE(m_MessageBar); ++i)
+	{
+		for (int j = 0; j < 5; ++j)
+		{
+			coronaCoord.x = m_Position.x + m_Size.x * i;
+			coronaCoord.y = m_Position.y + m_Size.y * i;
+			coronaCoord.z = m_Position.z + m_Size.z * j;
+
+			// Render main coronas
+			if (m_MessageBar[i] & (1 << j))
+			{
+				if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
+				{
+					CSprite::RenderBufferedOneXLUSprite(
+						screenCoord.x, screenCoord.y, screenCoord.z,
+						screenW * m_fScale, screenH * m_fScale,
+						r, g, b,
+						255, 1.0f / screenCoord.z, 255);
+				}
+			}
+			// Render smaller and faded coronas for a trailing effect
+			else if (m_MessageBar[i - 1] & (1 << j))
+			{
+				if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
+				{
+					CSprite::RenderBufferedOneXLUSprite(
+						screenCoord.x, screenCoord.y, screenCoord.z,
+						screenW * m_fScale * 0.8f,
+						screenH * m_fScale * 0.8f,
+						r / 2,
+						g / 2,
+						b / 2,
+						255, 1.0f / screenCoord.z, 255);
+				}
+			}
+		}
+	}
+
+	CSprite::FlushSpriteBuffer();
+}
+
+// ---------- CTowerClock ----------
+void CTowerClock::Init(CVector position, float sizeX, float sizeY, uint8 red, uint8 green, uint8 blue, float drawDistance, float scale)
+{
+	m_bVisible      = false;
+	m_Position      = position;
+	m_Size.x        = sizeX;
+	m_Size.y        = sizeY;
+	m_Size.z        = 0.0f;
+	m_uRed          = red;
+	m_uGreen        = green;
+	m_uBlue         = blue;
+	m_fDrawDistance = drawDistance;
+	m_fScale        = scale;
+}
+
+void CTowerClock::Update()
+{
+	float distanceFromCamera = (TheCamera.GetPosition() - m_Position).Magnitude();
+	if (distanceFromCamera < m_fDrawDistance)
+	{
+		m_bVisible = true;
+		if (distanceFromCamera < 0.75f * m_fDrawDistance)
+			m_fIntensity = 1.0f;
+		else
+			m_fIntensity = 1.0f - (distanceFromCamera - 0.75f * m_fDrawDistance) * 4.0f / m_fDrawDistance;
+	}
+	else
+		m_bVisible = false;
+}
+
+RwIm3DVertex TempV[4];
+void CTowerClock::Render()
+{
+	if (TheCamera.IsSphereVisible(m_Position, m_fScale))
+	{
+		// Calculate angle for each clock index
+		float angleHour   = 2.0f * (float)PI * (CClock::GetMinutes() + 60.0f * CClock::GetHours())   / 720.0f;
+		float angleMinute = 2.0f * (float)PI * (CClock::GetSeconds() + 60.0f * CClock::GetMinutes()) / 3600.0f;
+
+		// Prepare render states
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND,          (void*)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void*)rwBLENDINVSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATETEXTUREFILTER,     (void*)rwFILTERLINEAR);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER,     nil);
+
+		// Set vertices colors
+		RwIm3DVertexSetRGBA(&TempV[0], m_uRed, m_uGreen, m_uBlue, (uint8)(m_fIntensity * 255.0f));
+		RwIm3DVertexSetRGBA(&TempV[1], m_uRed, m_uGreen, m_uBlue, (uint8)(m_fIntensity * 255.0f));
+		RwIm3DVertexSetRGBA(&TempV[2], m_uRed, m_uGreen, m_uBlue, (uint8)(m_fIntensity * 255.0f));
+		RwIm3DVertexSetRGBA(&TempV[3], m_uRed, m_uGreen, m_uBlue, (uint8)(m_fIntensity * 255.0f));
+
+		// Set vertices position
+		RwIm3DVertexSetPos(&TempV[0], m_Position.x, m_Position.y, m_Position.z);
+		RwIm3DVertexSetPos(
+			&TempV[1],
+			m_Position.x + Sin(angleMinute) * m_fScale * m_Size.x,
+			m_Position.y + Sin(angleMinute) * m_fScale * m_Size.y,
+			m_Position.z + Cos(angleMinute) * m_fScale
+		);
+		RwIm3DVertexSetPos(&TempV[2], m_Position.x, m_Position.y, m_Position.z);
+		RwIm3DVertexSetPos(
+			&TempV[3],
+			m_Position.x + Sin(angleHour) * 0.75f * m_fScale * m_Size.x,
+			m_Position.y + Sin(angleHour) * 0.75f * m_fScale * m_Size.y,
+			m_Position.z + Cos(angleHour) * 0.75f * m_fScale
+		);
+
+		LittleTest();
+
+		// Draw lines
+		if (RwIm3DTransform(TempV, 4, nil, 0))
+		{
+			RwIm3DRenderLine(0, 1);
+			RwIm3DRenderLine(2, 3);
+			RwIm3DEnd();
+		}
+	}
+}
+
+// ---------- CDigitalClock ----------
+void CDigitalClock::Init(CVector position, float sizeX, float sizeY, uint8 red, uint8 green, uint8 blue, float drawDistance, float scale)
+{
+	m_bVisible      = false;
+	m_Position      = position;
+	m_Size.x        = sizeX;
+	m_Size.y        = sizeY;
+	m_Size.z        = 0.0f;
+	m_uRed          = red;
+	m_uGreen        = green;
+	m_uBlue         = blue;
+	m_fDrawDistance = drawDistance;
+	m_fScale        = scale;
+}
+
+void CDigitalClock::Update()
+{
+	float distanceFromCamera = (TheCamera.GetPosition() - m_Position).Magnitude();
+	if (distanceFromCamera < m_fDrawDistance)
+	{
+		m_bVisible = true;
+		if (distanceFromCamera < 0.75f * m_fDrawDistance)
+			m_fIntensity = 1.0f;
+		else
+			m_fIntensity = 1.0f - (distanceFromCamera - 0.75f * m_fDrawDistance) * 4.0f / m_fDrawDistance;
+	}
+	else
+		m_bVisible = false;
+}
+
+void CDigitalClock::Render()
+{
+	if (TheCamera.IsSphereVisible(m_Position, 5.0f * m_fScale))
+	{
+		CSprite::InitSpriteBuffer();
+
+		// Simulate flicker
+		float currentIntensity = m_fIntensity * CGeneral::GetRandomNumberInRange(0x300, 0x400) / 1024.0f;
+
+		uint8 r = currentIntensity * m_uRed;
+		uint8 g = currentIntensity * m_uGreen;
+		uint8 b = currentIntensity * m_uBlue;
+
+		// Set render states
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND,          (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATETEXTUREFILTER,     (void*)rwFILTERLINEAR);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER,     RwTextureGetRaster(gpCoronaTexture[0]));
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void*)TRUE);
+
+		const char* clockMessage = FindDigitalClockMessage();
+
+		CVector coronaCoord, screenCoord;
+		float screenW, screenH;
+		for (int c = 0; c < 5; ++c) // for each char to be displayed
+		{
+			for (int i = 0; i < 5; ++i) // for each column of coronas
+			{
+				for (int j = 0; j < 5; ++j) // for each row of coronas
+				{
+					if (ScrollCharSet[clockMessage[c] - ' '][i] & (1 << j))
+					{
+						coronaCoord.x = m_Position.x + (8 * c + i) * m_Size.x * m_fScale / 8.0f;
+						coronaCoord.y = m_Position.y + (8 * c + i) * m_Size.y * m_fScale / 8.0f;
+						coronaCoord.z = m_Position.z + j * m_fScale / 8.0f;
+
+						if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
+						{
+							CSprite::RenderBufferedOneXLUSprite(
+								screenCoord.x, screenCoord.y, screenCoord.z,
+								screenW * m_fScale * 0.12f,
+								screenW * m_fScale * 0.12f,
+								r, g, b,
+								255,
+								1.0f / screenCoord.z,
+								255);
+						}
+					}
+				}
+			}
+		}
+
+		CSprite::FlushSpriteBuffer();
+	}
+}
diff --git a/src/renderer/Fluff.h b/src/renderer/Fluff.h
new file mode 100644
index 00000000..fe3ab256
--- /dev/null
+++ b/src/renderer/Fluff.h
@@ -0,0 +1,106 @@
+#pragma once
+#include "common.h"
+#include "Vector.h"
+
+class CMovingThing
+{
+public:
+	CMovingThing *m_pNext;
+	CMovingThing *m_pPrev;
+	int16 m_nType;
+	int16 m_nHidden;
+	CVector m_vecPosn;
+	CEntity* m_pEntity;
+
+	void Update();
+	void AddToList(CMovingThing *pThing);
+	void RemoveFromList();
+	int16 SizeList();
+};
+
+#define NUMMOVINGTHINGS 128
+
+class CMovingThings
+{
+public:
+	static CMovingThing StartCloseList;
+	static CMovingThing EndCloseList;
+	static int16 Num;
+	static CMovingThing aMovingThings[NUMMOVINGTHINGS];
+
+	static void Init();
+	static void Shutdown();
+	static void Update();
+	static void Render();
+};
+
+class CScrollBar
+{
+private:
+	uint8       m_Counter;
+	const char* m_pMessage;
+	CVector     m_Position;
+	uint32      m_MessageCurrentChar;
+	uint32      m_MessageLength;
+	CVector     m_Size;
+	float       m_fIntensity;
+	uint8       m_MessageBar[40];
+	uint8       m_Type;
+	bool        m_bVisible;
+	uint8       m_uRed;
+	uint8       m_uGreen;
+	uint8       m_uBlue;
+	float       m_fScale;
+
+public:
+	void SetVisibility(bool visible) { m_bVisible = visible; }
+	bool IsVisible() { return m_bVisible; }
+
+	void Init(CVector, uint8, float, float, float, uint8, uint8, uint8, float);
+	void Update();
+	void Render();
+};
+
+class CTowerClock
+{
+private:
+	CVector m_Position;
+	CVector m_Size;
+	float   m_fDrawDistance;
+	float   m_fScale;
+	uint8   m_uRed;
+	uint8   m_uGreen;
+	uint8   m_uBlue;
+	bool    m_bVisible;
+	float   m_fIntensity;
+
+public:
+	void SetVisibility(bool visible) { m_bVisible = visible; }
+	bool IsVisible() { return m_bVisible; }
+
+	void Init(CVector, float, float, uint8, uint8, uint8, float, float);
+	void Update();
+	void Render();
+};
+
+class CDigitalClock
+{
+private:
+	CVector m_Position;
+	CVector m_Size;
+	float   m_fDrawDistance;
+	float   m_fScale;
+	uint8   m_uRed;
+	uint8   m_uGreen;
+	uint8   m_uBlue;
+	bool    m_bVisible;
+	float   m_fIntensity;
+
+public:
+	void SetVisibility(bool visible) { m_bVisible = visible; }
+	bool IsVisible() { return m_bVisible; }
+
+	void Init(CVector, float, float, uint8, uint8, uint8, float, float);
+	void Update();
+	void Render();
+};
\ No newline at end of file
diff --git a/src/renderer/Font.cpp b/src/renderer/Font.cpp
new file mode 100644
index 00000000..6a9944e1
--- /dev/null
+++ b/src/renderer/Font.cpp
@@ -0,0 +1,1628 @@
+#include "common.h"
+
+#include "Sprite2d.h"
+#include "TxdStore.h"
+#include "Font.h"
+#ifdef BUTTON_ICONS
+#include "FileMgr.h"
+#endif
+
+void
+AsciiToUnicode(const char *src, wchar *dst)
+{
+	while((*dst++ = (unsigned char)*src++) != '\0');
+}
+
+void
+UnicodeStrcat(wchar *dst, wchar *append)
+{
+	UnicodeStrcpy(&dst[UnicodeStrlen(dst)], append);
+}
+
+void
+UnicodeStrcpy(wchar *dst, const wchar *src)
+{
+	while((*dst++ = *src++) != '\0');
+}
+
+int
+UnicodeStrlen(const wchar *str)
+{
+	int len;
+	for(len = 0; *str != '\0'; len++, str++);
+	return len;
+}
+
+CFontDetails CFont::Details;
+bool16 CFont::NewLine;
+CSprite2d CFont::Sprite[MAX_FONTS];
+
+#ifdef MORE_LANGUAGES
+uint8 CFont::LanguageSet = FONT_LANGSET_EFIGS;
+int32 CFont::Slot = -1;
+#define JAP_TERMINATION (0x8000 | '~')
+
+int16 CFont::Size[LANGSET_MAX][MAX_FONTS][193] = {
+	{
+#else
+int16 CFont::Size[MAX_FONTS][193] = {
+#endif
+
+#if !defined(GTA_PS2) || defined(FIX_BUGS)
+		{
+		13, 12, 31, 35, 23, 35, 31,  9, 14, 15, 25, 30, 11, 17, 13, 31,
+		23, 16, 22, 21, 24, 23, 23, 20, 23, 22, 10, 35, 26, 26, 26, 26,
+		30, 26, 24, 23, 24, 22, 21, 24, 26, 10, 20, 26, 22, 29, 26, 25,
+		23, 25, 24, 24, 22, 25, 24, 29, 29, 23, 25, 37, 22, 37, 35, 37,
+		35, 21, 22, 21, 21, 22, 13, 22, 21, 10, 16, 22, 11, 32, 21, 21,
+		23, 22, 16, 20, 14, 21, 20, 30, 25, 21, 21, 33, 33, 33, 33, 35,
+		27, 27, 27, 27, 32, 24, 23, 23, 23, 23, 11, 11, 11, 11, 26, 26,
+		26, 26, 26, 26, 26, 25, 26, 21, 21, 21, 21, 32, 23, 22, 22, 22,
+		22, 11, 11, 11, 11, 22, 22, 22, 22, 22, 22, 22, 22, 26, 21, 24,
+		12, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+		26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 18, 26, 26,
+		26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+		20
+		},
+
+		{
+		13,  9, 21, 35, 23, 35, 35, 11, 35, 35, 25, 35, 11, 17, 13, 33,
+		28, 14, 22, 21, 24, 23, 23, 21, 23, 22, 10, 35, 13, 35, 13, 33,
+		 5, 25, 22, 23, 24, 21, 21, 24, 24,  9, 20, 24, 21, 27, 25, 25,
+		22, 25, 23, 20, 23, 23, 23, 31, 23, 23, 23, 37, 33, 37, 35, 37,
+		35, 21, 19, 19, 21, 19, 17, 21, 21,  8, 17, 18, 14, 24, 21, 21,
+		20, 22, 19, 20, 20, 19, 20, 26, 21, 20, 21, 33, 33, 33, 33, 35,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		16
+		},
+
+		{
+		15, 14, 16, 25, 19, 26, 22, 11, 18, 18, 27, 26, 13, 19,  9, 27,
+		19, 18, 19, 19, 22, 19, 20, 18, 19, 20, 12, 32, 15, 32, 15, 35,
+		15, 19, 19, 19, 19, 19, 16, 19, 20,  9, 19, 20, 14, 29, 19, 20,
+		19, 19, 19, 19, 21, 19, 20, 32, 20, 19, 19, 33, 31, 39, 37, 39,
+		37, 21, 21, 21, 23, 21, 19, 23, 23, 10, 19, 20, 16, 26, 23, 23,
+		20, 20, 20, 22, 21, 22, 22, 26, 22, 22, 23, 35, 35, 35, 35, 37,
+		19, 19, 19, 19, 29, 19, 19, 19, 19, 19,  9,  9,  9,  9, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 30, 19, 19, 19, 19,
+		19, 10, 10, 10, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 23, 35,
+		12, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 11, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19
+		}
+#else // #if defined(GTA_PS2) && !defined(FIX_BUGS)
+		{
+		13, 12, 31, 35, 23, 35, 31,  9, 14, 15, 25, 30, 11, 17, 13, 31,
+		23, 16, 22, 21, 24, 23, 23, 20, 23, 22, 10, 35, 26, 26, 26, 26,
+		30, 26, 24, 23, 24, 22, 21, 24, 26, 10, 20, 26, 22, 29, 26, 25,
+		24, 25, 24, 24, 22, 25, 24, 29, 29, 23, 25, 37, 22, 37, 35, 37,
+		35, 21, 22, 21, 21, 22, 13, 22, 21, 10, 16, 22, 11, 32, 21, 21,
+		23, 22, 16, 20, 14, 21, 20, 30, 25, 21, 21, 33, 33, 33, 33, 35,
+		27, 27, 27, 27, 32, 24, 23, 23, 23, 23, 11, 11, 11, 11, 26, 26,
+		26, 26, 26, 26, 26, 25, 26, 21, 21, 21, 21, 32, 23, 22, 22, 22,
+		22, 11, 11, 11, 11, 22, 22, 22, 22, 22, 22, 22, 22, 26, 21, 24,
+		12, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+		26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 18, 26, 26,
+		26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+		20
+		},
+
+		{
+		13,  9, 21, 35, 23, 35, 35, 11, 35, 35, 25, 35, 11, 17, 13, 33,
+		28, 14, 22, 21, 24, 23, 23, 21, 23, 22, 10, 35, 13, 35, 13, 33,
+		 5, 25, 22, 23, 24, 21, 21, 24, 24,  9, 20, 24, 21, 27, 25, 25,
+		22, 25, 23, 20, 23, 23, 23, 31, 23, 23, 23, 37, 33, 37, 35, 37,
+		35, 21, 19, 19, 21, 19, 17, 21, 21,  8, 17, 18, 14, 24, 21, 21,
+		20, 22, 19, 20, 20, 19, 20, 26, 21, 20, 21, 33, 33, 33, 33, 35,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		16
+		},
+
+		{
+		15, 14, 16, 25, 19, 26, 22, 11, 18, 18, 27, 26, 13, 19,  9, 27,
+		19, 18, 19, 19, 21, 19, 20, 18, 19, 20, 12, 32, 15, 32, 15, 35,
+		15, 19, 19, 19, 19, 19, 16, 19, 20,  9, 19, 20, 14, 29, 19, 19,
+		19, 19, 19, 19, 21, 19, 20, 32, 20, 19, 19, 33, 31, 39, 37, 39,
+		37, 21, 21, 21, 23, 21, 19, 23, 23, 10, 19, 20, 16, 26, 23, 23,
+		20, 20, 20, 22, 21, 22, 22, 26, 22, 22, 23, 35, 35, 35, 35, 37,
+		19, 19, 19, 19, 29, 19, 19, 19, 19, 19,  9,  9,  9,  9, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 30, 19, 19, 19, 19, 19,
+		10, 10, 10, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 23, 35, 12,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 11, 19, 19, 19,
+		19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+		19
+		}
+#endif
+
+#ifdef MORE_LANGUAGES
+	},
+	{
+		{ 13, 12, 31, 35, 23, 35, 31, 9, 14, 15, 25, 30, 11, 17,
+			13, 31, 23, 16, 22, 21, 24, 23, 23, 20, 23, 22, 10,
+			35, 26, 26, 26, 26, 30, 26, 24, 23, 24, 22, 21, 24,
+			26, 10, 20, 26, 22, 29, 26, 25, 23, 25, 24, 24, 22,
+			25, 24, 29, 29, 23, 25, 37, 22, 37, 35, 37, 35, 21,
+			22, 21, 21, 22, 13, 22, 21, 10, 16, 22, 11, 32, 21,
+			21, 23, 22, 16, 20, 14, 21, 20, 30, 25, 21, 21, 13,
+			33, 13, 13, 13, 24, 22, 22, 19, 26, 21, 30, 20, 23,
+			23, 21, 24, 26, 23, 22, 23, 21, 22, 20, 20, 26, 25,
+			24, 22, 31, 32, 23, 30, 22, 22, 32, 23, 19, 18, 18,
+			15, 22, 19, 27, 19, 20, 20, 18, 22, 24, 20, 19, 19,
+			20, 19, 16, 19, 28, 20, 20, 18, 26, 27, 19, 26, 18,
+			19, 27, 19, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+			26, 26, 26, 18, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+			26, 26, 26, 26, 26, 26, 26, 26, 26, 20 },
+		{ 13, 9, 21, 35, 23, 35, 35, 11, 35, 35, 25, 35, 11,
+			17, 13, 33, 28, 14, 22, 21, 24, 23, 23, 21, 23, 22,
+			10, 35, 13, 35, 13, 33, 5, 25, 22, 23, 24, 21, 21, 24,
+			24, 9, 20, 24, 21, 27, 25, 25, 22, 25, 23, 20, 23, 23,
+			23, 31, 23, 23, 23, 37, 33, 37, 35, 37, 35, 21, 19,
+			19, 21, 19, 17, 21, 21, 8, 17, 18, 14, 24, 21, 21, 20,
+			22, 19, 20, 20, 19, 20, 26, 21, 20, 21, 33, 33, 33,
+			33, 35, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 16, },
+		{ 15, 14, 16, 25, 19,
+			26, 22, 11, 18, 18, 27, 26, 13, 19, 9, 27, 19, 18, 19,
+			19, 22, 19, 20, 18, 19, 20, 12, 32, 15, 32, 15, 35,
+			15, 19, 19, 19, 19, 19, 16, 19, 20, 9, 19, 20, 14, 29,
+			19, 20, 19, 19, 19, 19, 21, 19, 20, 32, 20, 19, 19,
+			33, 31, 39, 37, 39, 37, 21, 21, 21, 23, 21, 19, 23, 23, 10, 19, 20, 16, 26, 23,
+			21, 21, 20, 20, 22, 21, 22, 22, 26, 22, 22, 23, 35,
+			35, 35, 35, 37, 19, 19, 19, 19, 19, 19, 29, 19, 19,
+			19, 20, 22, 31, 19, 19, 19, 19, 19, 29, 19, 29, 19,
+			21, 19, 30, 31, 21, 29, 19, 19, 29, 19, 21, 23, 32,
+			21, 21, 30, 31, 22, 21, 32, 33, 23, 32, 21, 21, 32,
+			21, 19, 19, 30, 31, 22, 22, 21, 32, 33, 23, 32, 21,
+			21, 32, 21, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 11, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19 },
+	},
+
+	{
+		{
+			13, 12, 31, 35, 23, 35, 31, 9, 14, 15, 25, 30, 11, 17, 13, 31,
+				23, 16, 22, 21, 24, 23, 23, 20, 23, 22, 10, 35, 26, 26, 26, 26,
+				30, 26, 24, 23, 24, 22, 21, 24, 26, 10, 20, 26, 22, 29, 26, 25,
+				23, 25, 24, 24, 22, 25, 24, 29, 29, 23, 25, 37, 22, 37, 35, 37,
+				35, 21, 22, 21, 21, 22, 13, 22, 21, 10, 16, 22, 11, 32, 21, 21,
+				23, 22, 16, 20, 14, 21, 20, 30, 25, 21, 21, 33, 33, 33, 33, 35,
+				27, 27, 27, 27, 32, 24, 23, 23, 23, 23, 11, 11, 11, 11, 26, 26,
+				26, 26, 26, 26, 26, 25, 26, 21, 21, 21, 21, 32, 23, 22, 22, 22,
+				22, 11, 11, 11, 11, 22, 22, 22, 22, 22, 22, 22, 22, 26, 21, 24,
+				12, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+				26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 18, 26, 26,
+				26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+				20
+		},
+
+		{
+			13,  9, 21, 35, 23, 35, 35, 11, 35, 35, 25, 35, 11, 17, 13, 33,
+			28, 14, 22, 21, 24, 23, 23, 21, 23, 22, 10, 35, 13, 35, 13, 33,
+			5, 25, 22, 23, 24, 21, 21, 24, 24,  9, 20, 24, 21, 27, 25, 25,
+			22, 25, 23, 20, 23, 23, 23, 31, 23, 23, 23, 37, 33, 37, 35, 37,
+			35, 21, 19, 19, 21, 19, 17, 21, 21,  8, 17, 18, 14, 24, 21, 21,
+			20, 22, 19, 20, 20, 19, 20, 26, 21, 20, 21, 33, 33, 33, 33, 35,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			16
+		},
+
+		{
+			15, 14, 16, 25, 19, 26, 22, 11, 18, 18, 27, 26, 13, 19,  9, 27,
+			19, 18, 19, 19, 22, 19, 20, 18, 19, 20, 12, 32, 15, 32, 15, 35,
+			15, 19, 19, 19, 19, 19, 16, 19, 20,  9, 19, 20, 14, 29, 19, 20,
+			19, 19, 19, 19, 21, 19, 20, 32, 20, 19, 19, 33, 31, 39, 37, 39,
+			37, 21, 21, 21, 23, 21, 19, 23, 23, 10, 19, 20, 16, 26, 23, 23,
+			20, 20, 20, 22, 21, 22, 22, 26, 22, 22, 23, 35, 35, 35, 35, 37,
+			19, 19, 19, 19, 29, 19, 19, 19, 19, 19,  9,  9,  9,  9, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 30, 19, 19, 19, 19,
+			19, 10, 10, 10, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 23, 35,
+			12, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 11, 19, 19,
+			19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+			19
+		}
+	}
+#endif
+};
+
+#ifdef MORE_LANGUAGES
+int16 Size_jp[] = {
+	15, 14, 16, 20, 19, 26, 22, 11, 18, 18, 27, 26, 13, //; 0
+	19, 20, 27, 19, 15, 19, 19, 21, 19, 20, 18, 19, 15, //; 13
+	13, 28, 15, 32, 15, 35, 15, 19, 19, 19, 19, 17, 16, //; 26
+	19, 20, 15, 19, 20, 14, 17, 19, 19, 19, 19, 19, 19, //; 39
+	19, 19, 20, 25, 20, 19, 19, 33, 31, 39, 37, 39, 37, //; 52
+	21, 21, 21, 19, 17, 15, 23, 21, 15, 19, 20, 16, 19, //; 65
+	19, 19, 20, 20, 17, 22, 19, 22, 22, 19, 22, 22, 23, //; 78
+	35, 35, 35, 35, 37, 19, 19, 19, 19, 29, 19, 19, 19, //; 91
+	19, 19, 9, 9, 9, 9, 19, 19, 19, 19, 19, 19, 19, 19, //; 104
+	19, 19, 19, 19, 19, 30, 19, 19, 19, 19, 19, 10, 10, //; 118
+	10, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 23, 35, //; 131
+	12, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, //; 144
+	19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, //; 157
+	19, 19, 19, 11, 19, 19, 19, 19, 19, 19, 19, 19, 19, //; 170
+	19, 19, 19, 19, 19, 19, 19, 19, 19, 21
+};
+#endif
+
+wchar foreign_table[128] = {
+	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+	  0, 176,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+	  0,   0,   0,   0, 177,   0,   0,   0,   0,   0,  95,   0,   0,   0,   0, 175,
+	128, 129, 130,   0, 131,   0, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
+	  0, 173, 142, 143, 144,   0, 145,   0,   0, 146, 147, 148, 149,   0,   0, 150,
+	151, 152, 153,   0, 154,   0, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
+	  0, 174, 165, 166, 167,   0, 168,   0,   0, 169, 170, 171, 172,   0,   0,   0,
+};
+
+#ifdef BUTTON_ICONS
+CSprite2d CFont::ButtonSprite[MAX_BUTTON_ICONS];
+int CFont::PS2Symbol = BUTTON_NONE;
+int CFont::ButtonsSlot = -1;
+#endif // BUTTON_ICONS
+
+void
+CFont::Initialise(void)
+{
+	int slot;
+
+	slot = CTxdStore::AddTxdSlot("fonts");
+#ifdef MORE_LANGUAGES
+	Slot = slot;
+	switch (LanguageSet)
+	{
+	case FONT_LANGSET_EFIGS:
+	default:
+		CTxdStore::LoadTxd(slot, "MODELS/FONTS.TXD");
+		break;
+	case FONT_LANGSET_POLISH:
+		CTxdStore::LoadTxd(slot, "MODELS/FONTS_P.TXD");
+		break;
+	case FONT_LANGSET_RUSSIAN:
+		CTxdStore::LoadTxd(slot, "MODELS/FONTS_R.TXD");
+		break;
+	case FONT_LANGSET_JAPANESE:
+		CTxdStore::LoadTxd(slot, "MODELS/FONTS_J.TXD");
+		break;
+	}
+#else
+	CTxdStore::LoadTxd(slot, "MODELS/FONTS.TXD");
+#endif
+	CTxdStore::AddRef(slot);
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(slot);
+	Sprite[0].SetTexture("font2", "font2_mask");
+#ifdef MORE_LANGUAGES
+	if (IsJapanese()) {
+		Sprite[1].SetTexture("FONTJAP", "FONTJAP_mask");
+		Sprite[3].SetTexture("FONTJAP", "FONTJAP_mask");
+	}
+	else
+#endif // MORE_LANGUAGES
+		Sprite[1].SetTexture("pager", "pager_mask");
+	Sprite[2].SetTexture("font1", "font1_mask");
+	SetScale(1.0f, 1.0f);
+	SetSlantRefPoint(SCREEN_WIDTH, 0.0f);
+	SetSlant(0.0f);
+	SetColor(CRGBA(255, 255, 255, 0));
+	SetJustifyOff();
+	SetCentreOff();
+#ifdef FIX_BUGS
+	SetWrapx(SCREEN_STRETCH_X(DEFAULT_SCREEN_WIDTH));
+	SetCentreSize(SCREEN_STRETCH_X(DEFAULT_SCREEN_WIDTH));
+#else
+	SetWrapx(DEFAULT_SCREEN_WIDTH);
+	SetCentreSize(DEFAULT_SCREEN_WIDTH);
+#endif
+	SetBackgroundOff();
+	SetBackgroundColor(CRGBA(128, 128, 128, 128));
+	SetBackGroundOnlyTextOff();
+	SetPropOn();
+	SetFontStyle(FONT_BANK);
+	SetRightJustifyWrap(0.0f);
+	SetAlphaFade(255.0f);
+	SetDropShadowPosition(0);
+	CTxdStore::PopCurrentTxd();
+
+#if !defined(GAMEPAD_MENU) && defined(BUTTON_ICONS)
+	// loaded in CMenuManager with GAMEPAD_MENU defined
+	LoadButtons("MODELS/X360BTNS.TXD");
+#endif
+}
+
+#ifdef BUTTON_ICONS
+void
+CFont::LoadButtons(const char* txdPath)
+{
+	if (int file = CFileMgr::OpenFile(txdPath)) {
+		CFileMgr::CloseFile(file);
+		if (ButtonsSlot == -1)
+			ButtonsSlot = CTxdStore::AddTxdSlot("buttons");
+		else {
+			for (int i = 0; i < MAX_BUTTON_ICONS; i++)
+				ButtonSprite[i].Delete();
+			CTxdStore::RemoveTxd(ButtonsSlot);
+		}
+		CTxdStore::LoadTxd(ButtonsSlot, txdPath);
+		CTxdStore::AddRef(ButtonsSlot);
+		CTxdStore::PushCurrentTxd();
+		CTxdStore::SetCurrentTxd(ButtonsSlot);
+#if 0  // unused
+		ButtonSprite[BUTTON_UP].SetTexture("up");
+		ButtonSprite[BUTTON_DOWN].SetTexture("down");
+		ButtonSprite[BUTTON_LEFT].SetTexture("left");
+		ButtonSprite[BUTTON_RIGHT].SetTexture("right");
+#endif
+		ButtonSprite[BUTTON_CROSS].SetTexture("cross");
+		ButtonSprite[BUTTON_CIRCLE].SetTexture("circle");
+		ButtonSprite[BUTTON_SQUARE].SetTexture("square");
+		ButtonSprite[BUTTON_TRIANGLE].SetTexture("triangle");
+		ButtonSprite[BUTTON_L1].SetTexture("l1");
+		ButtonSprite[BUTTON_L2].SetTexture("l2");
+		ButtonSprite[BUTTON_L3].SetTexture("l3");
+		ButtonSprite[BUTTON_R1].SetTexture("r1");
+		ButtonSprite[BUTTON_R2].SetTexture("r2");
+		ButtonSprite[BUTTON_R3].SetTexture("r3");
+		CTxdStore::PopCurrentTxd();
+	}
+	else {
+		if (ButtonsSlot != -1) {
+			for (int i = 0; i < MAX_BUTTON_ICONS; i++)
+				ButtonSprite[i].Delete();
+			CTxdStore::RemoveTxdSlot(ButtonsSlot);
+			ButtonsSlot = -1;
+		}
+	}
+}
+#endif // BUTTON_ICONS
+
+#ifdef MORE_LANGUAGES
+void
+CFont::ReloadFonts(uint8 set)
+{
+	if (Slot != -1 && LanguageSet != set) {
+		Sprite[0].Delete();
+		Sprite[1].Delete();
+		Sprite[2].Delete();
+		if (IsJapanese())
+			Sprite[3].Delete();
+		CTxdStore::PushCurrentTxd();
+		CTxdStore::RemoveTxd(Slot);
+		switch (set)
+		{
+		case FONT_LANGSET_EFIGS:
+		default:
+			CTxdStore::LoadTxd(Slot, "MODELS/FONTS.TXD");
+			break;
+		case FONT_LANGSET_POLISH:
+			CTxdStore::LoadTxd(Slot, "MODELS/FONTS_P.TXD");
+			break;
+		case FONT_LANGSET_RUSSIAN:
+			CTxdStore::LoadTxd(Slot, "MODELS/FONTS_R.TXD");
+			break;
+		case FONT_LANGSET_JAPANESE:
+			CTxdStore::LoadTxd(Slot, "MODELS/FONTS_J.TXD");
+			break;
+		}
+		CTxdStore::SetCurrentTxd(Slot);
+		Sprite[0].SetTexture("font2", "font2_mask");
+		if (set == FONT_LANGSET_JAPANESE) {
+			Sprite[1].SetTexture("FONTJAP", "FONTJAP_mask");
+			Sprite[3].SetTexture("FONTJAP", "FONTJAP_mask");
+		}
+		else
+			Sprite[1].SetTexture("pager", "pager_mask");
+		Sprite[2].SetTexture("font1", "font1_mask");
+		CTxdStore::PopCurrentTxd();
+	}
+	LanguageSet = set;
+}
+#endif
+
+void
+CFont::Shutdown(void)
+{
+#ifdef BUTTON_ICONS
+	if (ButtonsSlot != -1) {
+		for (int i = 0; i < MAX_BUTTON_ICONS; i++)
+			ButtonSprite[i].Delete();
+		CTxdStore::RemoveTxdSlot(ButtonsSlot);
+		ButtonsSlot = -1;
+	}
+#endif
+	Sprite[0].Delete();
+	Sprite[1].Delete();
+	Sprite[2].Delete();
+#ifdef MORE_LANGUAGES
+	if (IsJapanese())
+		Sprite[3].Delete();
+	CTxdStore::RemoveTxdSlot(Slot);
+	Slot = -1;
+#else
+	CTxdStore::RemoveTxdSlot(CTxdStore::FindTxdSlot("fonts"));
+#endif
+}
+
+void
+CFont::InitPerFrame(void)
+{
+	Details.bank = CSprite2d::GetBank(30, Sprite[0].m_pTexture);
+	CSprite2d::GetBank(15, Sprite[1].m_pTexture);
+	CSprite2d::GetBank(15, Sprite[2].m_pTexture);
+#ifdef MORE_LANGUAGES
+	if (IsJapanese())
+		CSprite2d::GetBank(15, Sprite[3].m_pTexture);
+#endif
+	SetDropShadowPosition(0);
+	NewLine = false;
+#ifdef BUTTON_ICONS
+	PS2Symbol = BUTTON_NONE;
+#endif
+}
+
+#ifdef BUTTON_ICONS
+void
+CFont::DrawButton(float x, float y)
+{
+	if (x <= 0.0f || x > SCREEN_WIDTH || y <= 0.0f || y > SCREEN_HEIGHT)
+		return;
+
+	if (PS2Symbol != BUTTON_NONE) {
+		CRect rect;
+		rect.left = x;
+		rect.top = Details.scaleY + Details.scaleY + y;
+		rect.right = Details.scaleY * 17.0f + x;
+		rect.bottom = Details.scaleY * 19.0f + y;
+
+		int vertexAlphaState;
+		RwRenderStateGet(rwRENDERSTATEVERTEXALPHAENABLE, &vertexAlphaState);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+		ButtonSprite[PS2Symbol].Draw(rect, CRGBA(255, 255, 255, Details.color.a));
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)vertexAlphaState);
+	}
+}
+#endif
+
+void
+CFont::PrintChar(float x, float y, wchar c)
+{
+	if(x <= 0.0f || x > SCREEN_WIDTH ||
+#ifdef FIX_BUGS
+	   y <= 0.0f || y > SCREEN_HEIGHT)
+#else
+	   y <= 0.0f || y > SCREEN_WIDTH)
+#endif
+		return;
+
+	float w = GetCharacterWidth(c) / 32.0f;
+	float xoff = c % 16;
+	float yoff = c / 16;
+#ifdef MORE_LANGUAGES
+	if (IsJapaneseFont()) {
+		w = 21.0f;
+		xoff = (float)(c % 48);
+		yoff = c / 48;
+	}
+#endif
+
+	if(Details.style == FONT_BANK || Details.style == FONT_HEADING){
+		if(Details.dropShadowPosition != 0){
+			CSprite2d::AddSpriteToBank(
+#ifdef FIX_BUGS
+				Details.bank + Details.style,
+#else
+				Details.style, // BUG: game doesn't add bank
+#endif
+#ifdef FIX_BUGS
+				CRect(x + SCREEN_SCALE_X(Details.dropShadowPosition),
+				      y + SCREEN_SCALE_Y(Details.dropShadowPosition),
+				      x + SCREEN_SCALE_X(Details.dropShadowPosition) + 32.0f * Details.scaleX * 1.0f,
+				      y + SCREEN_SCALE_Y(Details.dropShadowPosition) + 40.0f * Details.scaleY * 0.5f),
+#else
+				CRect(x + Details.dropShadowPosition,
+				      y + Details.dropShadowPosition,
+				      x + Details.dropShadowPosition + 32.0f * Details.scaleX * 1.0f,
+				      y + Details.dropShadowPosition + 40.0f * Details.scaleY * 0.5f),
+#endif
+				Details.dropColor,
+				xoff/16.0f,                 yoff/12.8f,
+				(xoff+1.0f)/16.0f - 0.001f, yoff/12.8f,
+				xoff/16.0f,                 (yoff+1.0f)/12.8f,
+				(xoff+1.0f)/16.0f - 0.001f, (yoff+1.0f)/12.8f - 0.0001f);
+		}
+		CSprite2d::AddSpriteToBank(
+#ifdef FIX_BUGS
+			Details.bank + Details.style,
+#else
+			Details.style, // BUG: game doesn't add bank
+#endif
+			CRect(x, y,
+			      x + 32.0f * Details.scaleX * 1.0f,
+			      y + 40.0f * Details.scaleY * 0.5f),
+			Details.color,
+			xoff/16.0f,                 yoff/12.8f,
+			(xoff+1.0f)/16.0f - 0.001f, yoff/12.8f,
+			xoff/16.0f,                 (yoff+1.0f)/12.8f - 0.002f,
+			(xoff+1.0f)/16.0f - 0.001f, (yoff+1.0f)/12.8f - 0.002f);
+#ifdef MORE_LANGUAGES
+	}else if (IsJapaneseFont()) {
+		if (Details.dropShadowPosition != 0) {
+			CSprite2d::AddSpriteToBank(
+#ifdef FIX_BUGS
+				Details.bank + Details.style,
+#else
+				Details.style, // BUG: game doesn't add bank
+#endif
+#ifdef FIX_BUGS
+				CRect(x + SCREEN_SCALE_X(Details.dropShadowPosition),
+					y + SCREEN_SCALE_Y(Details.dropShadowPosition),
+					x + SCREEN_SCALE_X(Details.dropShadowPosition) + 32.0f * Details.scaleX * 1.0f,
+					y + SCREEN_SCALE_Y(Details.dropShadowPosition) + 40.0f * Details.scaleY / 2.75f),
+#else
+				CRect(x + Details.dropShadowPosition,
+					y + Details.dropShadowPosition,
+					x + Details.dropShadowPosition + 32.0f * Details.scaleX * 1.0f,
+					y + Details.dropShadowPosition + 40.0f * Details.scaleY / 2.75f),
+#endif
+				Details.dropColor,
+				xoff * w / 1024.0f, yoff / 25.6f,
+				xoff * w / 1024.0f + (1.0f / 48.0f) - 0.001f, yoff / 25.6f,
+				xoff * w / 1024.0f, (yoff + 1.0f) / 25.6f,
+				xoff * w / 1024.0f + (1.0f / 48.0f) - 0.001f, (yoff + 1.0f) / 25.6f - 0.0001f);
+		}
+		CSprite2d::AddSpriteToBank(Details.bank + Details.style,	// BUG: game doesn't add bank
+			CRect(x, y,
+				x + 32.0f * Details.scaleX * 1.0f,
+				y + 40.0f * Details.scaleY / 2.75f),
+			Details.color,
+			xoff * w / 1024.0f, yoff / 25.6f,
+			xoff * w / 1024.0f + (1.0f / 48.0f) - 0.001f, yoff / 25.6f,
+			xoff * w / 1024.0f, (yoff + 1.0f) / 25.6f - 0.002f,
+			xoff * w / 1024.0f + (1.0f / 48.0f) - 0.001f, (yoff + 1.0f) / 25.6f - 0.0001f);
+#endif
+	}else
+	{
+		CSprite2d::AddSpriteToBank(
+#ifdef FIX_BUGS
+			Details.bank + Details.style,
+#else
+			Details.style, // BUG: game doesn't add bank
+#endif
+			CRect(x, y,
+					x + 32.0f * Details.scaleX * w,
+					y + 32.0f * Details.scaleY * 0.5f),
+			Details.color,
+			xoff/16.0f,               yoff/16.0f,
+			(xoff+w)/16.0f,           yoff/16.0f,
+			xoff/16.0f,               (yoff+1.0f)/16.0f,
+			(xoff+w)/16.0f - 0.0001f, (yoff+1.0f)/16.0f - 0.0001f);
+	}
+}
+
+#ifdef MORE_LANGUAGES
+bool CFont::IsJapanesePunctuation(wchar *str)
+{
+	return (*str == 0xE7 || *str == 0x124 || *str == 0x126 || *str == 0x128 || *str == 0x104 || *str == ',' || *str == '>' || *str == '!' || *str == 0x99 || *str == '?' || *str == ':');
+}
+
+bool CFont::IsAnsiCharacter(wchar *s)
+{
+	if (*s >= 'A' && *s <= 'Z')
+		return true;
+	if (*s >= 'a' && *s <= 'z')
+		return true;
+	if (*s >= '0' && *s <= ':')
+		return true;
+	if (*s == '(' || *s == ')')
+		return true;
+	if (*s == 'D' || *s == '$')
+		return true;
+	return false;
+}
+#endif
+
+void
+CFont::PrintString(float xstart, float ystart, wchar *s)
+{
+	CRect rect;
+	int numSpaces;
+	float lineLength;
+	float x, y;
+	bool first;
+	wchar *start, *t;
+
+	if(*s == '*')
+		return;
+
+	if(Details.background){
+		GetNumberLines(xstart, ystart, s);	// BUG: result not used
+		GetTextRect(&rect, xstart, ystart, s);
+		CSprite2d::DrawRect(rect, Details.backgroundColor);
+	}
+
+	lineLength = 0.0f;
+	numSpaces = 0;
+	first = true;
+	if(Details.centre || Details.rightJustify)
+		x = 0.0f;
+	else
+		x = xstart;
+	y = ystart;
+	start = s;
+
+	// This is super ugly, I blame R*
+	for(;;){
+		for(;;){
+			for(;;){
+				if(*s == '\0')
+					return;
+				float xend = Details.centre ? Details.centreSize :
+				           Details.rightJustify ? xstart - Details.rightJustifyWrap :
+				           Details.wrapX;
+#ifdef MORE_LANGUAGES
+				if (IsJapaneseFont())
+					xend -= SCREEN_SCALE_X(21.0f * 2.0f);
+#endif
+				if(x + GetStringWidth(s) > xend && !first){
+#ifdef MORE_LANGUAGES
+					if (IsJapanese() && IsJapanesePunctuation(s))
+						s--;
+#endif
+					// flush line
+					float spaceWidth = !Details.justify || Details.centre ? 0.0f :
+						(Details.wrapX - lineLength) / numSpaces;
+					float xleft = Details.centre ? xstart - x/2 :
+					              Details.rightJustify ? xstart - x :
+					              xstart;
+#ifdef MORE_LANGUAGES
+					PrintString(xleft, y, start, s, spaceWidth, xstart);
+#else
+					PrintString(xleft, y, start, s, spaceWidth);
+#endif
+					// reset things
+					lineLength = 0.0f;
+					numSpaces = 0;
+					first = true;
+					if(Details.centre || Details.rightJustify)
+						x = 0.0f;
+					else
+						x = xstart;
+#ifdef MORE_LANGUAGES
+					if (IsJapaneseFont())
+						y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
+					else
+#endif
+						y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
+					start = s;
+				}else
+					break;
+			}
+			// advance by one word
+			t = GetNextSpace(s);
+			if(t[0] == '\0' ||
+			   t[0] == ' ' && t[1] == '\0')
+				break;
+			if(!first)
+				numSpaces++;
+			first = false;
+			x += GetStringWidth(s) + GetCharacterSize(*t - ' ');
+#ifdef MORE_LANGUAGES
+			if (IsJapaneseFont() && IsAnsiCharacter(s))
+				x += 21.0f;
+#endif
+			lineLength = x;
+			s = t+1;
+#ifdef MORE_LANGUAGES
+			if (IsJapaneseFont() && !*s) {
+				x += GetStringWidth(s);
+				if (IsAnsiCharacter(s))
+					x += 21.0f;
+				float xleft = Details.centre ? xstart - x / 2 :
+					Details.rightJustify ? xstart - x :
+					xstart;
+				if (PrintString(xleft, y, start, s, 0.0f, xstart))
+				{
+					start = s;
+					if (!Details.centre && !Details.rightJustify)
+						x = xstart;
+					else
+						x = 0.0f;
+
+					y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
+					numSpaces = 0;
+					first = true;
+					lineLength = 0.0f;
+				}
+			}
+#endif
+		}
+		// print rest
+		if(t[0] == ' ' && t[1] == '\0')
+			t[0] = '\0';
+		x += GetStringWidth(s);
+		s = t;
+		float xleft = Details.centre ? xstart - x/2 :
+		              Details.rightJustify ? xstart - x :
+		              xstart;
+#ifdef MORE_LANGUAGES
+		if (PrintString(xleft, y, start, s, 0.0f, xstart) && IsJapaneseFont()) {
+			start = s;
+			if (!Details.centre && !Details.rightJustify)
+				x = xstart;
+			else
+				x = 0.0f;
+			y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
+			numSpaces = 0;
+			first = true;
+			lineLength = 0.0f;
+		}
+#else
+		PrintString(xleft, y, start, s, 0.0f);
+#endif
+	}
+}
+
+int
+CFont::GetNumberLines(float xstart, float ystart, wchar *s)
+{
+	int n;
+	float x, y;
+	wchar *t;
+	n = 0;
+
+#ifdef MORE_LANGUAGES
+	bool bSomeJapBool = false;
+
+	if (IsJapanese()) {
+		t = s;
+		wchar unused;
+		while (*t) {
+			if (*t == JAP_TERMINATION || *t == '~')
+				t = ParseToken(t, &unused, true);
+			if (NewLine) {
+				n++;
+				NewLine = false;
+				bSomeJapBool = true;
+			}
+			t++;
+		}
+	}
+
+	if (bSomeJapBool) n--;
+#endif
+
+	if(Details.centre || Details.rightJustify)
+		x = 0.0f;
+	else
+		x = xstart;
+	y = ystart;
+
+	while(*s){
+#ifdef FIX_BUGS
+		float f = Details.centre ? Details.centreSize :
+		           Details.rightJustify ? xstart - Details.rightJustifyWrap :
+		           Details.wrapX;
+#else
+		float f = (Details.centre ? Details.centreSize : Details.wrapX);
+#endif
+
+#ifdef MORE_LANGUAGES
+		if (IsJapaneseFont())
+			f -= SCREEN_SCALE_X(21.0f * 2.0f);
+#endif
+
+		if(x + GetStringWidth(s) > f){
+#ifdef MORE_LANGUAGES
+			if (IsJapanese())
+			{
+				if (IsJapanesePunctuation(s))
+					s--;
+			}
+#endif
+			// reached end of line
+			if(Details.centre || Details.rightJustify)
+				x = 0.0f;
+			else
+				x = xstart;
+			n++;
+			// Why even?
+#ifdef MORE_LANGUAGES
+			if (IsJapanese())
+				y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
+			else
+#endif
+				y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
+		}else{
+			// still space in current line
+			t = GetNextSpace(s);
+			if(*t == '\0'){
+				// end of string
+				x += GetStringWidth(s);
+#ifdef MORE_LANGUAGES
+				if (IsJapanese() && IsAnsiCharacter(s))
+					x += 21.0f;
+#endif
+				n++;
+				s = t;
+			}else{
+				x += GetStringWidth(s);
+#ifdef MORE_LANGUAGES
+				if (IsJapanese() && IsAnsiCharacter(s))
+					x += 21.0f;
+#endif
+				s = t+1;
+				x += GetCharacterSize(*t - ' ');
+#ifdef MORE_LANGUAGES
+				if (IsJapanese() && !*s)
+					n++;
+#endif
+			}
+		}
+	}
+
+	return n;
+}
+
+void
+CFont::GetTextRect(CRect *rect, float xstart, float ystart, wchar *s)
+{
+	int numLines;
+	float x, y;
+	int16 maxlength;
+	wchar *t;
+
+	maxlength = 0;
+	numLines = 0;
+
+#ifdef MORE_LANGUAGES
+	if (IsJapanese()) {
+		numLines = GetNumberLines(xstart, ystart, s);
+	}else{
+#endif
+
+#ifdef FIX_BUGS
+		if(Details.centre || Details.rightJustify)
+#else
+		if(Details.centre)
+#endif
+			x = 0.0f;
+		else
+			x = xstart;
+		y = ystart;
+
+#ifdef FIX_BUGS
+		float xEnd = Details.centre ? Details.centreSize :
+		           Details.rightJustify ? xstart - Details.rightJustifyWrap :
+		           Details.wrapX;
+#else
+		float xEnd = (Details.centre ? Details.centreSize : Details.wrapX);
+#endif
+		while(*s){
+			if(x + GetStringWidth(s) > xEnd){
+				// reached end of line
+				if(x > maxlength)
+					maxlength = x;
+#ifdef FIX_BUGS
+				if(Details.centre || Details.rightJustify)
+#else
+				if(Details.centre)
+#endif
+					x = 0.0f;
+				else
+					x = xstart;
+				numLines++;
+				y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
+			}else{
+				// still space in current line
+				t = GetNextSpace(s);
+				if(*t == '\0'){
+					// end of string
+					x += GetStringWidth(s);
+					if(x > maxlength)
+						maxlength = x;
+					numLines++;
+					s = t;
+				}else{
+					x += GetStringWidth(s);
+					x += GetCharacterSize(*t - ' ');
+					s = t+1;
+				}
+			}
+		}
+#ifdef MORE_LANGUAGES
+	}
+#endif
+
+	if(Details.centre){
+		if(Details.backgroundOnlyText){
+			rect->left = xstart - maxlength/2 - 4.0f;
+			rect->right = xstart + maxlength/2 + 4.0f;
+#ifdef MORE_LANGUAGES
+			if (IsJapaneseFont()) {
+				rect->bottom = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
+				rect->top = ystart - (4.0f / 2.75f);
+			} else {
+#endif
+				rect->bottom = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f;
+				rect->top = ystart - 2.0f;
+#ifdef MORE_LANGUAGES
+			}
+#endif
+		}else{
+			rect->left = xstart - Details.centreSize*0.5f - 4.0f;
+			rect->right = xstart + Details.centreSize*0.5f + 4.0f;
+#ifdef MORE_LANGUAGES
+			if (IsJapaneseFont()) {
+				rect->bottom = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
+				rect->top = ystart - (4.0f / 2.75f);
+			} else {
+#endif
+				rect->bottom = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f;
+				rect->top = ystart - 2.0f;
+#ifdef MORE_LANGUAGES
+			}
+#endif
+		}
+	}else{
+		rect->left = xstart - 4.0f;
+		rect->right = Details.wrapX;
+		// WTF?
+		rect->bottom = ystart - 4.0f + 4.0f;
+#ifdef MORE_LANGUAGES
+		if (IsJapaneseFont())
+			rect->top = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f + (4.0f / 2.75f);
+		else
+#endif
+			rect->top = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f + 2.0f;
+	}
+}
+
+#ifdef MORE_LANGUAGES
+bool
+CFont::PrintString(float x, float y, wchar *start, wchar *&end, float spwidth, float japX)
+{
+	wchar *s, c, unused;
+
+	if (IsJapanese()) {
+		float jx = 0.0f;
+		for (s = start; s < end; s++) {
+			if (*s == JAP_TERMINATION || *s == '~')
+				s = ParseToken(s, &unused, true);
+			if (NewLine) {
+				NewLine = false;
+				break;
+			}
+			jx += GetCharacterSize(*s - ' ');
+		}
+		s = start;
+		if (Details.centre)
+			x = japX - jx / 2.0f;
+		else if (Details.rightJustify)
+			x = japX - jx;
+	}
+
+	for (s = start; s < end; s++) {
+		if (*s == '~' || (IsJapanese() && *s == JAP_TERMINATION))
+			s = ParseToken(s, &unused);
+		if (NewLine && IsJapanese()) {
+			NewLine = false;
+			end = s;
+			return true;
+		}
+		c = *s - ' ';
+		if (Details.slant != 0.0f && !IsJapanese())
+			y = (Details.slantRefX - x) * Details.slant + Details.slantRefY;
+
+#ifdef BUTTON_ICONS
+		if (PS2Symbol != BUTTON_NONE) {
+			DrawButton(x, y);
+			x += Details.scaleY * 17.0f;
+			PS2Symbol = BUTTON_NONE;
+		}
+#endif
+
+		PrintChar(x, y, c);
+		x += GetCharacterSize(c);
+		if (c == 0 && (!NewLine || !IsJapanese()))	// space
+			x += spwidth;
+	}
+	return false;
+}
+#else
+void
+CFont::PrintString(float x, float y, wchar *start, wchar *end, float spwidth)
+{
+	wchar *s, c, unused;
+
+	for(s = start; s < end; s++){
+		if(*s == '~')
+			s = ParseToken(s, &unused);
+		c = *s - ' ';
+		if(Details.slant != 0.0f)
+			y = (Details.slantRefX - x)*Details.slant + Details.slantRefY;
+		PrintChar(x, y, c);
+		x += GetCharacterSize(c);
+		if(c == 0)	// space
+			x += spwidth;
+	}
+}
+#endif
+
+void
+CFont::PrintStringFromBottom(float x, float y, wchar *str)
+{
+#ifdef MORE_LANGUAGES
+	if (IsJapaneseFont())
+		y -= (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * GetNumberLines(x, y, str);
+	else
+#endif
+		y -= (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * GetNumberLines(x, y, str);
+	PrintString(x, y, str);
+}
+
+#ifdef XBOX_SUBTITLES
+void
+CFont::PrintOutlinedString(float x, float y, wchar *str, float outlineStrength, bool fromBottom, CRGBA outlineColor)
+{
+	CRGBA textColor = Details.color;
+	SetColor(outlineColor);
+	CVector2D offsets[] = { {1.f, 1.f}, {1.f, -1.f}, {-1.f, 1.f}, {-1.f, -1.f} };
+	for(int i = 0; i < ARRAY_SIZE(offsets); i++){
+		if (fromBottom)
+			PrintStringFromBottom(x + SCREEN_SCALE_X(offsets[i].x * outlineStrength), y + SCREEN_SCALE_Y(offsets[i].y * outlineStrength), str);
+		else
+			PrintString(x + SCREEN_SCALE_X(offsets[i].x * outlineStrength), y + SCREEN_SCALE_Y(offsets[i].y * outlineStrength), str);
+	}
+	SetColor(textColor);
+	
+	if (fromBottom)
+		PrintStringFromBottom(x, y, str);
+	else
+		PrintString(x, y, str);
+}
+#endif
+
+float
+CFont::GetCharacterWidth(wchar c)
+{
+#ifdef MORE_LANGUAGES
+	if (IsJapanese()) {
+		if (!Details.proportional)
+			return Size[0][Details.style][192];
+		if (c <= 94 || Details.style == FONT_HEADING || Details.style == FONT_BANK) {
+			switch (Details.style)
+			{
+			case FONT_JAPANESE:
+				return Size_jp[c];
+			default:
+				return Size[0][Details.style][c];
+			}
+		}
+		if (c < 254 && Details.style == FONT_PAGER)
+			return 29.4f;
+
+		switch (Details.style)
+		{
+		case FONT_JAPANESE:
+			return 29.4f;
+		case FONT_BANK:
+			return 10.0f;
+		case FONT_PAGER:
+			return 31.5f;
+		default:
+			return Size[0][Details.style][c];
+		}
+	}
+
+	else if (Details.proportional)
+		return Size[LanguageSet][Details.style][c];
+	else
+		return Size[LanguageSet][Details.style][192];
+#else
+	if (Details.proportional)
+		return Size[Details.style][c];
+	else
+		return Size[Details.style][192];
+#endif // MORE_LANGUAGES
+}
+
+float
+CFont::GetCharacterSize(wchar c)
+{
+#ifdef MORE_LANGUAGES
+
+	if (IsJapanese())
+	{
+		if (!Details.proportional)
+			return Size[0][Details.style][192] * Details.scaleX;
+		if (c <= 94 || Details.style == FONT_HEADING || Details.style == FONT_BANK) {
+			switch (Details.style)
+			{
+			case FONT_JAPANESE:
+				return Size_jp[c] * Details.scaleX;
+			default:
+				return Size[0][Details.style][c] * Details.scaleX;
+			}
+		}
+		if (c < 254 && (Details.style == FONT_PAGER))
+			return 29.4f * Details.scaleX;
+
+		switch (Details.style)
+		{
+		case FONT_JAPANESE:
+			return 29.4f * Details.scaleX;
+		case FONT_BANK:
+			return 10.0f * Details.scaleX;
+		case FONT_PAGER:
+			return 31.5f * Details.scaleX;
+		default:
+			return Size[0][Details.style][c] * Details.scaleX;
+		}
+	}
+	else if(Details.proportional)
+		return Size[LanguageSet][Details.style][c] * Details.scaleX;
+	else
+		return Size[LanguageSet][Details.style][192] * Details.scaleX;
+#else
+	if (Details.proportional)
+		return Size[Details.style][c] * Details.scaleX;
+	else
+		return Size[Details.style][192] * Details.scaleX;
+#endif // MORE_LANGUAGES
+}
+
+float
+CFont::GetStringWidth(wchar *s, bool spaces)
+{
+	float w;
+
+	w = 0.0f;
+#ifdef MORE_LANGUAGES
+	if (IsJapanese())
+	{
+		do
+		{
+			if ((*s != ' ' || spaces) && *s != '\0') {
+				do {
+					while (*s == '~' || *s == JAP_TERMINATION) {
+						s++;
+#ifdef BUTTON_ICONS
+						switch (*s) {
+#if 0 // unused
+						case 'U':
+						case 'D':
+						case '<':
+						case '>':
+#endif
+						case 'X':
+						case 'O':
+						case 'Q':
+						case 'T':
+						case 'K':
+						case 'M':
+						case 'A':
+						case 'J':
+						case 'V':
+						case 'C':
+							w += 17.0f * Details.scaleY;
+							break;
+						default:
+							break;
+						}
+#endif
+						while (!(*s == '~' || *s == JAP_TERMINATION)) s++;
+						s++;
+					}
+					w += GetCharacterSize(*s - ' ');
+					++s;
+				} while (*s == '~' || *s == JAP_TERMINATION);
+			}
+		} while (IsAnsiCharacter(s));
+	} else
+#endif
+	{
+		for (; (*s != ' ' || spaces) && *s != '\0'; s++) {
+			if (*s == '~') {
+				s++;
+#ifdef BUTTON_ICONS
+				switch (*s) {
+#if 0 // unused
+				case 'U':
+				case 'D':
+				case '<':
+				case '>':
+#endif
+				case 'X':
+				case 'O':
+				case 'Q':
+				case 'T':
+				case 'K':
+				case 'M':
+				case 'A':
+				case 'J':
+				case 'V':
+				case 'C':
+					w += 17.0f * Details.scaleY;
+					break;
+				default:
+					break;
+				}
+#endif
+				while (*s != '~') s++;
+#ifndef FIX_BUGS
+				s++;
+				if (*s == ' ' && !spaces)
+					break;
+			} 
+#else
+			} else
+#endif
+				w += GetCharacterSize(*s - ' ');
+		}
+	}
+	return w;
+}
+
+#ifdef MORE_LANGUAGES
+float
+CFont::GetStringWidth_Jap(wchar* s)
+{
+	float w;
+
+	w = 0.0f;
+	for (; *s != '\0';) {
+		do {
+			while (*s == '~' || *s == JAP_TERMINATION) {
+				s++;
+				while (!(*s == '~' || *s == JAP_TERMINATION)) s++;
+				s++;
+			}
+			w += GetCharacterSize(*s - ' ');
+			++s;
+		} while (*s == '~' || *s == JAP_TERMINATION);
+	}
+	return w;
+}
+#endif
+
+wchar*
+CFont::GetNextSpace(wchar *s)
+{
+#ifdef MORE_LANGUAGES
+	if (IsJapanese()) {
+		do
+		{
+			if (*s != ' ' && *s != '\0') {
+				do {
+					while (*s == '~' || *s == JAP_TERMINATION) {
+						s++;
+						while (!(*s == '~' || *s == JAP_TERMINATION)) s++;
+						s++;
+					}
+					++s;
+				} while (*s == '~' || *s == JAP_TERMINATION);
+			}
+		} while (IsAnsiCharacter(s));
+	} else
+#endif
+	{
+		for(; *s != ' ' && *s != '\0'; s++)
+			if(*s == '~'){
+				s++;
+				while(*s != '~') s++;
+#ifndef FIX_BUGS
+				s++;
+				if(*s == ' ')
+					break;
+#endif
+			}
+	}
+	return s;
+}
+
+#ifdef MORE_LANGUAGES
+wchar*
+CFont::ParseToken(wchar *s, wchar* ss, bool japShit)
+{
+	s++;
+	if ((Details.color.r || Details.color.g || Details.color.b) && !japShit) {
+		wchar c = *s;
+		if (IsJapanese())
+			c &= 0x7FFF;
+		switch (c) {
+		case 'N':
+		case 'n':
+			NewLine = true;
+			break;
+		case 'b': SetColor(CRGBA(128, 167, 243, 255)); break;
+		case 'g': SetColor(CRGBA(95, 160, 106, 255)); break;
+		case 'h': SetColor(CRGBA(225, 225, 225, 255)); break;
+		case 'l': SetColor(CRGBA(0, 0, 0, 255)); break;
+		case 'p': SetColor(CRGBA(168, 110, 252, 255)); break;
+		case 'r': SetColor(CRGBA(113, 43, 73, 255)); break;
+		case 'w': SetColor(CRGBA(175, 175, 175, 255)); break;
+		case 'y': SetColor(CRGBA(210, 196, 106, 255)); break;
+#ifdef BUTTON_ICONS
+#if 0 // unused
+		case 'U': PS2Symbol = BUTTON_UP; break;
+		case 'D': PS2Symbol = BUTTON_DOWN; break;
+		case '<': PS2Symbol = BUTTON_LEFT; break;
+		case '>': PS2Symbol = BUTTON_RIGHT; break;
+#endif
+		case 'X': PS2Symbol = BUTTON_CROSS; break;
+		case 'O': PS2Symbol = BUTTON_CIRCLE; break;
+		case 'Q': PS2Symbol = BUTTON_SQUARE; break;
+		case 'T': PS2Symbol = BUTTON_TRIANGLE; break;
+		case 'K': PS2Symbol = BUTTON_L1; break;
+		case 'M': PS2Symbol = BUTTON_L2; break;
+		case 'A': PS2Symbol = BUTTON_L3; break;
+		case 'J': PS2Symbol = BUTTON_R1; break;
+		case 'V': PS2Symbol = BUTTON_R2; break;
+		case 'C': PS2Symbol = BUTTON_R3; break;
+#endif
+		}
+	} else if (IsJapanese()) {
+		if ((*s & 0x7FFF) == 'N' || (*s & 0x7FFF) == 'n')
+			NewLine = true;
+	}
+	while ((!IsJapanese() || (*s != JAP_TERMINATION)) && *s != '~') s++;
+#ifdef FIX_BUGS
+	if (*(++s) == '~')
+		s = ParseToken(s, ss, japShit);
+	return s;
+#else
+	return s + 1;
+#endif
+}
+#else
+wchar*
+CFont::ParseToken(wchar *s, wchar*)
+{
+	s++;
+	if(Details.color.r || Details.color.g || Details.color.b)
+		switch(*s){
+		case 'N':
+		case 'n':
+			NewLine = true;
+			break;
+		case 'b': SetColor(CRGBA(128, 167, 243, 255)); break;
+		case 'g': SetColor(CRGBA(95, 160, 106, 255)); break;
+		case 'h': SetColor(CRGBA(225, 225, 225, 255)); break;
+		case 'l': SetColor(CRGBA(0, 0, 0, 255)); break;
+		case 'p': SetColor(CRGBA(168, 110, 252, 255)); break;
+		case 'r': SetColor(CRGBA(113, 43, 73, 255)); break;
+		case 'w': SetColor(CRGBA(175, 175, 175, 255)); break;
+		case 'y': SetColor(CRGBA(210, 196, 106, 255)); break;
+#ifdef BUTTON_ICONS
+#if 0 // unused
+		case 'U': PS2Symbol = BUTTON_UP; break;
+		case 'D': PS2Symbol = BUTTON_DOWN; break;
+		case '<': PS2Symbol = BUTTON_LEFT; break;
+		case '>': PS2Symbol = BUTTON_RIGHT; break;
+#endif
+		case 'X': PS2Symbol = BUTTON_CROSS; break;
+		case 'O': PS2Symbol = BUTTON_CIRCLE; break;
+		case 'Q': PS2Symbol = BUTTON_SQUARE; break;
+		case 'T': PS2Symbol = BUTTON_TRIANGLE; break;
+		case 'K': PS2Symbol = BUTTON_L1; break;
+		case 'M': PS2Symbol = BUTTON_L2; break;
+		case 'A': PS2Symbol = BUTTON_L3; break;
+		case 'J': PS2Symbol = BUTTON_R1; break;
+		case 'V': PS2Symbol = BUTTON_R2; break;
+		case 'C': PS2Symbol = BUTTON_R3; break;
+#endif
+		}
+	while(*s != '~') s++;
+	return s+1;
+}
+#endif
+
+void
+CFont::DrawFonts(void)
+{
+	CSprite2d::DrawBank(Details.bank);
+	CSprite2d::DrawBank(Details.bank+1);
+	CSprite2d::DrawBank(Details.bank+2);
+#ifdef MORE_LANGUAGES
+	if (IsJapanese())
+		CSprite2d::DrawBank(Details.bank+3);
+#endif
+}
+
+
+void
+CFont::SetScale(float x, float y)
+{
+#ifdef MORE_LANGUAGES
+	/*if (IsJapanese()) {
+		x *= 1.35f;
+		y *= 1.25f;
+	}*/
+#endif
+	Details.scaleX = x;
+	Details.scaleY = y;
+}
+
+void
+CFont::SetSlantRefPoint(float x, float y)
+{
+	Details.slantRefX = x;
+	Details.slantRefY = y;
+}
+
+void
+CFont::SetSlant(float s)
+{
+	Details.slant = s;
+}
+
+void
+CFont::SetColor(CRGBA col)
+{
+	Details.color = col;
+	if (Details.alphaFade < 255.0f)
+		Details.color.a *= Details.alphaFade / 255.0f;
+}
+
+void
+CFont::SetJustifyOn(void)
+{
+	Details.justify = true;
+	Details.centre = false;
+	Details.rightJustify = false;
+}
+
+void
+CFont::SetJustifyOff(void)
+{
+	Details.justify = false;
+	Details.rightJustify = false;
+}
+
+void
+CFont::SetCentreOn(void)
+{
+	Details.centre = true;
+	Details.justify = false;
+	Details.rightJustify = false;
+}
+
+void
+CFont::SetCentreOff(void)
+{
+	Details.centre = false;
+}
+
+void
+CFont::SetWrapx(float x)
+{
+	Details.wrapX = x;
+}
+
+void
+CFont::SetCentreSize(float s)
+{
+	Details.centreSize = s;
+}
+
+void
+CFont::SetBackgroundOn(void)
+{
+	Details.background = true;
+}
+
+void
+CFont::SetBackgroundOff(void)
+{
+	Details.background = false;
+}
+
+void
+CFont::SetBackgroundColor(CRGBA col)
+{
+	Details.backgroundColor = col;
+}
+
+void
+CFont::SetBackGroundOnlyTextOn(void)
+{
+	Details.backgroundOnlyText = true;
+}
+
+void
+CFont::SetBackGroundOnlyTextOff(void)
+{
+	Details.backgroundOnlyText = false;
+}
+
+void
+CFont::SetRightJustifyOn(void)
+{
+	Details.rightJustify = true;
+	Details.justify = false;
+	Details.centre = false;
+}
+
+void
+CFont::SetRightJustifyOff(void)
+{
+	Details.rightJustify = false;
+	Details.justify = false;
+	Details.centre = false;
+}
+
+void
+CFont::SetPropOn(void)
+{
+	Details.proportional = true;
+}
+
+void
+CFont::SetPropOff(void)
+{
+	Details.proportional = false;
+}
+
+void
+CFont::SetFontStyle(int16 style)
+{
+	Details.style = style;
+}
+
+void
+CFont::SetRightJustifyWrap(float wrap)
+{
+	Details.rightJustifyWrap = wrap;
+}
+
+void
+CFont::SetAlphaFade(float fade)
+{
+	Details.alphaFade = fade;
+}
+
+void
+CFont::SetDropColor(CRGBA col)
+{
+	Details.dropColor = col;
+	if (Details.alphaFade < 255.0f)
+		Details.dropColor.a *= Details.alphaFade / 255.0f;
+}
+
+void
+CFont::SetDropShadowPosition(int16 pos)
+{
+	Details.dropShadowPosition = pos;
+}
+
+wchar
+CFont::character_code(uint8 c)
+{
+	if(c < 128)
+		return c;
+	return foreign_table[c-128];
+}
\ No newline at end of file
diff --git a/src/renderer/Font.h b/src/renderer/Font.h
new file mode 100644
index 00000000..9316ed34
--- /dev/null
+++ b/src/renderer/Font.h
@@ -0,0 +1,182 @@
+#pragma once
+
+#include "Sprite2d.h"
+
+void AsciiToUnicode(const char *src, wchar *dst);
+void UnicodeStrcpy(wchar *dst, const wchar *src);
+void UnicodeStrcat(wchar *dst, wchar *append);
+int UnicodeStrlen(const wchar *str);
+
+struct CFontDetails
+{
+	CRGBA color;
+	float scaleX;
+	float scaleY;
+	float slant;
+	float slantRefX;
+	float slantRefY;
+	bool8 justify;
+	bool8 centre;
+	bool8 rightJustify;
+	bool8 background;
+	bool8 backgroundOnlyText;
+	bool8 proportional;
+	float alphaFade;
+	CRGBA backgroundColor;
+	float wrapX;
+	float centreSize;
+	float rightJustifyWrap;
+	int16 style;
+	int32 bank;
+	int16 dropShadowPosition;
+	CRGBA dropColor;
+};
+
+class CSprite2d;
+
+enum {
+	FONT_BANK,
+	FONT_PAGER,
+	FONT_HEADING,
+#ifdef MORE_LANGUAGES
+	FONT_JAPANESE,
+#endif
+	MAX_FONTS
+};
+
+enum {
+	ALIGN_LEFT,
+	ALIGN_CENTER,
+	ALIGN_RIGHT,
+};
+
+#ifdef MORE_LANGUAGES
+enum
+{
+	FONT_LANGSET_EFIGS,
+	FONT_LANGSET_RUSSIAN,
+	FONT_LANGSET_POLISH,
+	FONT_LANGSET_JAPANESE,
+	LANGSET_MAX
+};
+
+#define FONT_LOCALE(style) (CFont::IsJapanese() ? FONT_JAPANESE : style)
+#else
+#define FONT_LOCALE(style) (style)
+#endif
+
+#ifdef BUTTON_ICONS
+enum
+{
+	BUTTON_NONE = -1,
+#if 0 // unused
+	BUTTON_UP,
+	BUTTON_DOWN,
+	BUTTON_LEFT,
+	BUTTON_RIGHT,
+#endif
+	BUTTON_CROSS,
+	BUTTON_CIRCLE,
+	BUTTON_SQUARE,
+	BUTTON_TRIANGLE,
+	BUTTON_L1,
+	BUTTON_L2,
+	BUTTON_L3,
+	BUTTON_R1,
+	BUTTON_R2,
+	BUTTON_R3,
+	MAX_BUTTON_ICONS
+};
+#endif // BUTTON_ICONS
+
+
+class CFont
+{
+#ifdef MORE_LANGUAGES
+	static int16 Size[LANGSET_MAX][MAX_FONTS][193];
+	static uint8 LanguageSet;
+	static int32 Slot;
+#else
+	static int16 Size[MAX_FONTS][193];
+#endif
+	static bool16 NewLine;
+public:
+	static CSprite2d Sprite[MAX_FONTS];
+	static CFontDetails Details;
+
+#ifdef BUTTON_ICONS
+	static int32 ButtonsSlot;
+	static CSprite2d ButtonSprite[MAX_BUTTON_ICONS];
+	static int PS2Symbol;
+
+	static void LoadButtons(const char *txdPath);
+	static void DrawButton(float x, float y);
+#endif // BUTTON_ICONS
+
+
+	static void Initialise(void);
+	static void Shutdown(void);
+	static void InitPerFrame(void);
+	static void PrintChar(float x, float y, wchar c);
+	static void PrintString(float x, float y, wchar *s);
+	static void PrintStringFromBottom(float x, float y, wchar *str);
+#ifdef XBOX_SUBTITLES
+	static void PrintOutlinedString(float x, float y, wchar *str, float outlineStrength, bool fromBottom, CRGBA outlineColor);
+#endif
+	static int GetNumberLines(float xstart, float ystart, wchar *s);
+	static void GetTextRect(CRect *rect, float xstart, float ystart, wchar *s);
+#ifdef MORE_LANGUAGES
+	static bool PrintString(float x, float y, wchar *start, wchar* &end, float spwidth, float japX);
+#else
+	static void PrintString(float x, float y, wchar *start, wchar *end, float spwidth);
+#endif
+	static float GetCharacterWidth(wchar c);
+	static float GetCharacterSize(wchar c);
+	static float GetStringWidth(wchar *s, bool spaces = false);
+#ifdef MORE_LANGUAGES
+	static float GetStringWidth_Jap(wchar* s);
+#endif
+	static uint16 *GetNextSpace(wchar *s);
+#ifdef MORE_LANGUAGES
+	static uint16 *ParseToken(wchar *s, wchar*, bool japShit = false);
+#else
+	static uint16 *ParseToken(wchar *s, wchar*);
+#endif
+	static void DrawFonts(void);
+	static uint16 character_code(uint8 c);
+
+	static void SetScale(float x, float y);
+	static void SetSlantRefPoint(float x, float y);
+	static void SetSlant(float s);
+	static void SetJustifyOn(void);
+	static void SetJustifyOff(void);
+	static void SetRightJustifyOn(void);
+	static void SetRightJustifyOff(void);
+	static void SetCentreOn(void);
+	static void SetCentreOff(void);
+	static void SetWrapx(float x);
+	static void SetCentreSize(float s);
+	static void SetBackgroundOn(void);
+	static void SetBackgroundOff(void);
+	static void SetBackGroundOnlyTextOn(void);
+	static void SetBackGroundOnlyTextOff(void);
+	static void SetPropOn(void);
+	static void SetPropOff(void);
+	static void SetFontStyle(int16 style);
+	static void SetRightJustifyWrap(float wrap);
+	static void SetAlphaFade(float fade);
+	static void SetDropShadowPosition(int16 pos);
+	static void SetBackgroundColor(CRGBA col);
+	static void SetColor(CRGBA col);
+	static void SetDropColor(CRGBA col);
+
+#ifdef MORE_LANGUAGES
+	static void ReloadFonts(uint8 set);
+
+	// japanese stuff
+	static bool IsAnsiCharacter(wchar* s);
+	static bool IsJapanesePunctuation(wchar* str);
+	static bool IsJapanese() { return LanguageSet == FONT_LANGSET_JAPANESE; }
+	static bool IsJapaneseFont() { return IsJapanese() && (Details.style == FONT_JAPANESE || Details.style == FONT_PAGER);  }
+#endif
+};
diff --git a/src/renderer/Glass.cpp b/src/renderer/Glass.cpp
new file mode 100644
index 00000000..cc45648c
--- /dev/null
+++ b/src/renderer/Glass.cpp
@@ -0,0 +1,719 @@
+#include "common.h"
+
+#include "Glass.h"
+#include "Timer.h"
+#include "Object.h"
+#include "General.h"
+#include "AudioScriptObject.h"
+#include "World.h"
+#include "Timecycle.h"
+#include "Particle.h"
+#include "Camera.h"
+#include "RenderBuffer.h"
+#include "Shadows.h"
+#include "ModelIndices.h"
+#include "main.h"
+#include "soundlist.h"
+
+
+uint32 CGlass::NumGlassEntities;
+CEntity *CGlass::apEntitiesToBeRendered[NUM_GLASSENTITIES];
+CFallingGlassPane CGlass::aGlassPanes[NUM_GLASSPANES];
+
+
+CVector2D CentersWithTriangle[NUM_GLASSTRIANGLES];
+const CVector2D CoorsWithTriangle[NUM_GLASSTRIANGLES][3] =
+{
+	{
+		CVector2D(0.0f, 0.0f),
+		CVector2D(0.0f, 1.0f),
+		CVector2D(0.4f, 0.5f)
+	},
+
+	{
+		CVector2D(0.0f, 1.0f),
+		CVector2D(1.0f, 1.0f),
+		CVector2D(0.4f, 0.5f)
+	},
+
+	{
+		CVector2D(0.0f, 0.0f),
+		CVector2D(0.4f, 0.5f),
+		CVector2D(0.7f, 0.0f)
+	},
+
+	{
+		CVector2D(0.7f, 0.0f),
+		CVector2D(0.4f, 0.5f),
+		CVector2D(1.0f, 1.0f)
+	},
+
+	{
+		CVector2D(0.7f, 0.0f),
+		CVector2D(1.0f, 1.0f),
+		CVector2D(1.0f, 0.0f)
+	}
+};
+
+#define TEMPBUFFERVERTHILIGHTOFFSET     0
+#define TEMPBUFFERINDEXHILIGHTOFFSET    0
+#define TEMPBUFFERVERTHILIGHTSIZE       128
+#define TEMPBUFFERINDEXHILIGHTSIZE      512
+
+#define TEMPBUFFERVERTSHATTEREDOFFSET   TEMPBUFFERVERTHILIGHTSIZE
+#define TEMPBUFFERINDEXSHATTEREDOFFSET  TEMPBUFFERINDEXHILIGHTSIZE
+#define TEMPBUFFERVERTSHATTEREDSIZE     192
+#define TEMPBUFFERINDEXSHATTEREDSIZE    768
+
+#define TEMPBUFFERVERTREFLECTIONOFFSET  TEMPBUFFERVERTSHATTEREDSIZE
+#define TEMPBUFFERINDEXREFLECTIONOFFSET TEMPBUFFERINDEXSHATTEREDSIZE
+#define TEMPBUFFERVERTREFLECTIONSIZE    256
+#define TEMPBUFFERINDEXREFLECTIONSIZE   1024
+
+int32 TempBufferIndicesStoredHiLight     = 0;
+int32 TempBufferVerticesStoredHiLight    = 0;
+int32 TempBufferIndicesStoredShattered   = 0;
+int32 TempBufferVerticesStoredShattered  = 0;
+int32 TempBufferIndicesStoredReflection  = 0;
+int32 TempBufferVerticesStoredReflection = 0;
+
+void
+CFallingGlassPane::Update(void)
+{
+	if ( CTimer::GetTimeInMilliseconds() >= m_nTimer )
+	{
+		// Apply MoveSpeed
+		GetPosition()    += m_vecMoveSpeed * CTimer::GetTimeStep();
+
+		// Apply Gravity
+		m_vecMoveSpeed.z -= 0.02f         *  CTimer::GetTimeStep();
+
+		// Apply TurnSpeed
+		GetRight()   += CrossProduct(m_vecTurn, GetRight());
+		GetForward() += CrossProduct(m_vecTurn, GetForward());
+		GetUp()      += CrossProduct(m_vecTurn, GetUp());
+
+		if ( GetPosition().z < m_fGroundZ )
+		{
+			CVector pos;
+			CVector dir;
+
+			m_bActive = false;
+
+			pos = CVector(GetPosition().x, GetPosition().y, m_fGroundZ);
+
+			PlayOneShotScriptObject(SCRIPT_SOUND_GLASS_LIGHT_BREAK, pos);
+
+			RwRGBA color = { 255, 255, 255, 255 };
+
+			static int32 nFrameGen = 0;
+
+			for ( int32 i = 0; i < 4; i++ )
+			{
+				dir.x = CGeneral::GetRandomNumberInRange(-0.35f, 0.35f);
+				dir.y = CGeneral::GetRandomNumberInRange(-0.35f, 0.35f);
+				dir.z = CGeneral::GetRandomNumberInRange(0.05f, 0.20f);
+
+				CParticle::AddParticle(PARTICLE_CAR_DEBRIS,
+					pos,
+					dir,
+					nil,
+					CGeneral::GetRandomNumberInRange(0.02f, 0.2f),
+					color,
+					CGeneral::GetRandomNumberInRange(-40, 40),
+					0,
+					++nFrameGen & 3,
+					500);
+			}
+		}
+	}
+}
+
+void
+CFallingGlassPane::Render(void)
+{
+	float distToCamera = (TheCamera.GetPosition() - GetPosition()).Magnitude();
+
+	CVector fwdNorm = GetForward();
+	fwdNorm.Normalise();
+	uint8 alpha = CGlass::CalcAlphaWithNormal(&fwdNorm);
+
+#ifdef FIX_BUGS
+	uint16 time = Clamp(CTimer::GetTimeInMilliseconds() > m_nTimer ? CTimer::GetTimeInMilliseconds() - m_nTimer : 0u, 0u, 500u);
+#else
+	uint16 time = Clamp(CTimer::GetTimeInMilliseconds() - m_nTimer, 0, 500);
+#endif
+
+	uint8 color = int32( float(alpha) * (float(time) / 500) );
+
+	if ( TempBufferIndicesStoredHiLight >= TEMPBUFFERINDEXHILIGHTSIZE-7 || TempBufferVerticesStoredHiLight >= TEMPBUFFERVERTHILIGHTSIZE-4 )
+		CGlass::RenderHiLightPolys();
+
+	// HiLight Polys
+
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 0], color, color, color, color);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 1], color, color, color, color);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 2], color, color, color, color);
+
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 0], 0.5f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 0], 0.5f);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 1], 0.5f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 1], 0.6f);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 2], 0.6f);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 2], 0.6f);
+
+	ASSERT(m_nTriIndex < NUM_GLASSTRIANGLES);
+
+	CVector2D p0 = CoorsWithTriangle[m_nTriIndex][0] - CentersWithTriangle[m_nTriIndex];
+	CVector2D p1 = CoorsWithTriangle[m_nTriIndex][1] - CentersWithTriangle[m_nTriIndex];
+	CVector2D p2 = CoorsWithTriangle[m_nTriIndex][2] - CentersWithTriangle[m_nTriIndex];
+	CVector v0 = *this * CVector(p0.x, 0.0f, p0.y);
+	CVector v1 = *this * CVector(p1.x, 0.0f, p1.y);
+	CVector v2 = *this * CVector(p2.x, 0.0f, p2.y);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 0], v0.x, v0.y, v0.z);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 1], v1.x, v1.y, v1.z);
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredHiLight + 2], v2.x, v2.y, v2.z);
+
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 0] = TempBufferVerticesStoredHiLight + 0;
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 1] = TempBufferVerticesStoredHiLight + 1;
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 2] = TempBufferVerticesStoredHiLight + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 3] = TempBufferVerticesStoredHiLight + 0;
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 4] = TempBufferVerticesStoredHiLight + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStoredHiLight + 5] = TempBufferVerticesStoredHiLight + 1;
+
+	TempBufferVerticesStoredHiLight += 3;
+	TempBufferIndicesStoredHiLight  += 6;
+
+	if ( m_bShattered )
+	{
+		if ( TempBufferIndicesStoredShattered >= TEMPBUFFERINDEXSHATTEREDSIZE-7 || TempBufferVerticesStoredShattered >= TEMPBUFFERVERTSHATTEREDSIZE-4 )
+			CGlass::RenderShatteredPolys();
+
+		uint8 shatteredColor = 255;
+		if ( distToCamera > 30.0f )
+			shatteredColor = int32((1.0f - (distToCamera - 30.0f) * 4.0f / 40.0f) * 255);
+
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], shatteredColor, shatteredColor, shatteredColor, shatteredColor);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], shatteredColor, shatteredColor, shatteredColor, shatteredColor);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], shatteredColor, shatteredColor, shatteredColor, shatteredColor);
+
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], 4.0f * CoorsWithTriangle[m_nTriIndex][0].x * m_fStep);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], 4.0f * CoorsWithTriangle[m_nTriIndex][0].y * m_fStep);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], 4.0f * CoorsWithTriangle[m_nTriIndex][1].x * m_fStep);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], 4.0f * CoorsWithTriangle[m_nTriIndex][1].y * m_fStep);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], 4.0f * CoorsWithTriangle[m_nTriIndex][2].x * m_fStep);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], 4.0f * CoorsWithTriangle[m_nTriIndex][2].y * m_fStep);
+
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], v0.x, v0.y, v0.z);
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], v1.x, v1.y, v1.z);
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], v2.x, v2.y, v2.z);
+
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 0] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 0;
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 1] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 1;
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 2] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 2;
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 3] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 0;
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 4] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 2;
+		TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 5] = TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET + 1;
+
+		TempBufferIndicesStoredShattered  += 6;
+		TempBufferVerticesStoredShattered += 3;
+	}
+}
+
+void
+CGlass::Init(void)
+{
+	for ( int32 i = 0; i < NUM_GLASSPANES; i++ )
+		aGlassPanes[i].m_bActive = false;
+
+	for ( int32 i = 0; i < NUM_GLASSTRIANGLES; i++  )
+		CentersWithTriangle[i] = (CoorsWithTriangle[i][0] + CoorsWithTriangle[i][1] + CoorsWithTriangle[i][2]) / 3;
+}
+
+void
+CGlass::Update(void)
+{
+	for ( int32 i = 0; i < NUM_GLASSPANES; i++ )
+	{
+		if ( aGlassPanes[i].m_bActive )
+			aGlassPanes[i].Update();
+	}
+}
+
+void
+CGlass::Render(void)
+{
+	TempBufferVerticesStoredHiLight    = 0;
+	TempBufferIndicesStoredHiLight     = 0;
+
+	TempBufferVerticesStoredShattered  = TEMPBUFFERVERTSHATTEREDOFFSET;
+	TempBufferIndicesStoredShattered   = TEMPBUFFERINDEXSHATTEREDOFFSET;
+
+	TempBufferVerticesStoredReflection = TEMPBUFFERVERTREFLECTIONOFFSET;
+	TempBufferIndicesStoredReflection  = TEMPBUFFERINDEXREFLECTIONOFFSET;
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATETEXTUREFILTER,     (void *)rwFILTERLINEAR);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,         (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGCOLOR,          (void *)RWRGBALONG(CTimeCycle::GetFogRed(), CTimeCycle::GetFogGreen(), CTimeCycle::GetFogBlue(), 255));
+	RwRenderStateSet(rwRENDERSTATESRCBLEND,          (void *)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void *)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+
+	PUSH_RENDERGROUP("CGlass::Render");
+
+	for ( int32 i = 0; i < NUM_GLASSPANES; i++ )
+	{
+		if ( aGlassPanes[i].m_bActive )
+			aGlassPanes[i].Render();
+	}
+
+	for ( uint32 i = 0; i < NumGlassEntities; i++ )
+		RenderEntityInGlass(apEntitiesToBeRendered[i]);
+
+	POP_RENDERGROUP();
+
+	NumGlassEntities = 0;
+
+	RenderHiLightPolys();
+	RenderShatteredPolys();
+	RenderReflectionPolys();
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,  (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND,     (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND,    (void *)rwBLENDINVSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,    (void *)FALSE);
+}
+
+CFallingGlassPane *
+CGlass::FindFreePane(void)
+{
+	for ( int32 i = 0; i < NUM_GLASSPANES; i++ )
+	{
+		if ( !aGlassPanes[i].m_bActive )
+			return &aGlassPanes[i];
+	}
+
+	return nil;
+}
+
+void
+CGlass::GeneratePanesForWindow(uint32 type, CVector pos, CVector up, CVector right, CVector speed, CVector point,
+								float moveSpeed, bool cracked, bool explosion)
+{
+	float upLen    = up.Magnitude();
+	float rightLen = right.Magnitude();
+
+	float upSteps = upLen + 0.75f;
+	if ( upSteps < 1.0f ) upSteps = 1.0f;
+
+	float rightSteps = rightLen + 0.75f;
+	if ( rightSteps < 1.0f ) rightSteps = 1.0f;
+
+	uint32 ysteps = (uint32)upSteps;
+	if ( ysteps > 3 ) ysteps = 3;
+
+	uint32 xsteps = (uint32)rightSteps;
+	if ( xsteps > 3 ) xsteps = 3;
+
+	if ( explosion )
+	{
+		if ( ysteps > 1 ) ysteps = 1;
+		if ( xsteps > 1 ) xsteps = 1;
+	}
+
+	float upScl    = upLen    / float(ysteps);
+	float rightScl = rightLen / float(xsteps);
+
+	bool bZFound;
+	float groundZ = CWorld::FindGroundZFor3DCoord(pos.x, pos.y, pos.z, &bZFound);
+	if ( !bZFound ) groundZ = pos.z - 2.0f;
+
+	for ( uint32 y = 0; y < ysteps; y++  )
+	{
+		for ( uint32 x = 0; x < xsteps; x++ )
+		{
+			float stepy = float(y) * upLen    / float(ysteps);
+			float stepx = float(x) * rightLen / float(xsteps);
+
+			for ( int32 i = 0; i < NUM_GLASSTRIANGLES; i++ )
+			{
+				CFallingGlassPane *pane = FindFreePane();
+				if ( pane )
+				{
+					pane->m_nTriIndex = i;
+					
+					pane->GetRight()  = (right * rightScl) / rightLen;
+#ifdef FIX_BUGS
+					pane->GetUp()     = (up    * upScl)    / upLen;
+#else
+					pane->GetUp()     = (up    * upScl)    / rightLen; // copypaste bug
+#endif
+					CVector fwd = CrossProduct(pane->GetRight(), pane->GetUp());
+					fwd.Normalise();
+
+					pane->GetForward() = fwd;
+
+					pane->GetPosition() = right / rightLen * (rightScl * CentersWithTriangle[i].x + stepx)
+										+ up    / upLen    * (upScl    * CentersWithTriangle[i].y + stepy)
+										+ pos;
+
+					pane->m_vecMoveSpeed.x = float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0015f + speed.x;
+					pane->m_vecMoveSpeed.y = float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0015f + speed.y;
+					pane->m_vecMoveSpeed.z = 0.0f + speed.z;
+
+					if ( moveSpeed != 0.0f )
+					{
+						CVector dist = pane->GetPosition() - point;
+						dist.Normalise();
+
+						pane->m_vecMoveSpeed += moveSpeed * dist;
+					}
+
+					pane->m_vecTurn.x = float((CGeneral::GetRandomNumber() & 127) - 64) * 0.002f;
+					pane->m_vecTurn.y = float((CGeneral::GetRandomNumber() & 127) - 64) * 0.002f;
+					pane->m_vecTurn.z = float((CGeneral::GetRandomNumber() & 127) - 64) * 0.002f;
+
+					switch ( type )
+					{
+						case 0:
+							pane->m_nTimer = CTimer::GetTimeInMilliseconds();
+							break;
+						case 1:
+							float dist = (pane->GetPosition() - point).Magnitude();
+							pane->m_nTimer = uint32(dist*100 + CTimer::GetTimeInMilliseconds());
+							break;
+					}
+
+					pane->m_fGroundZ = groundZ;
+					pane->m_bShattered = cracked;
+					pane->m_fStep = upLen / float(ysteps);
+					pane->m_bActive = true;
+				}
+			}
+		}
+	}
+}
+
+void
+CGlass::AskForObjectToBeRenderedInGlass(CEntity *entity)
+{
+#ifdef FIX_BUGS
+	if ( NumGlassEntities < NUM_GLASSENTITIES )
+#else
+	if ( NumGlassEntities < NUM_GLASSENTITIES-1 )
+#endif
+	{
+		apEntitiesToBeRendered[NumGlassEntities++] = entity;
+	}
+}
+
+void
+CGlass::RenderEntityInGlass(CEntity *entity)
+{
+	ASSERT(entity!=nil);
+	CObject *object = (CObject *)entity;
+
+	if ( object->bGlassBroken )
+		return;
+
+	float distToCamera = (TheCamera.GetPosition() - object->GetPosition()).Magnitude();
+
+	if ( distToCamera > 40.0f )
+		return;
+
+	CVector fwdNorm = object->GetForward();
+	fwdNorm.Normalise();
+	uint8 alpha = CalcAlphaWithNormal(&fwdNorm);
+
+	CColModel *col = object->GetColModel();
+	ASSERT(col!=nil);
+	if ( col->numTriangles >= 2 )
+	{
+		CVector a = object->GetMatrix() * col->vertices[0].Get();
+		CVector b = object->GetMatrix() * col->vertices[1].Get();
+		CVector c = object->GetMatrix() * col->vertices[2].Get();
+		CVector d = object->GetMatrix() * col->vertices[3].Get();
+
+		if ( object->bGlassCracked )
+		{
+			uint8 color = 255;
+			if ( distToCamera > 30.0f )
+				color = int32((1.0f - (distToCamera - 30.0f) * 4.0f / 40.0f) * 255);
+
+			if ( TempBufferIndicesStoredShattered >= TEMPBUFFERINDEXSHATTEREDSIZE-13 || TempBufferVerticesStoredShattered >= TEMPBUFFERVERTSHATTEREDSIZE-5 )
+				RenderShatteredPolys();
+
+			RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], color, color, color, color);
+			RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], color, color, color, color);
+			RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], color, color, color, color);
+			RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 3], color, color, color, color);
+
+			RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], 0.0f);
+			RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], 0.0f);
+			RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], 16.0f);
+			RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], 0.0f);
+			RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], 0.0f);
+			RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], 16.0f);
+			RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 3], 16.0f);
+			RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 3], 16.0f);
+
+			RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 0], a.x, a.y, a.z);
+			RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 1], b.x, b.y, b.z);
+			RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 2], c.x, c.y, c.z);
+			RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredShattered + 3], d.x, d.y, d.z);
+
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 0]  = col->triangles[0].a + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 1]  = col->triangles[0].b + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 2]  = col->triangles[0].c + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 3]  = col->triangles[1].a + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 4]  = col->triangles[1].b + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 5]  = col->triangles[1].c + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 6]  = col->triangles[0].a + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 7]  = col->triangles[0].c + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 8]  = col->triangles[0].b + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 9]  = col->triangles[1].a + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 10] = col->triangles[1].c + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+			TempBufferRenderIndexList[TempBufferIndicesStoredShattered + 11] = col->triangles[1].b + TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET;
+
+			TempBufferIndicesStoredShattered  += 12;
+			TempBufferVerticesStoredShattered += 4;
+		}
+
+		if ( TempBufferIndicesStoredReflection >= TEMPBUFFERINDEXREFLECTIONSIZE-13 || TempBufferVerticesStoredReflection >= TEMPBUFFERVERTREFLECTIONSIZE-5 )
+			RenderReflectionPolys();
+
+		uint8 color = 100;
+		if ( distToCamera > 30.0f )
+			color = int32((1.0f - (distToCamera - 30.0f) * 4.0f / 40.0f) * 100);
+
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 0], color, color, color, color);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 1], color, color, color, color);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 2], color, color, color, color);
+		RwIm3DVertexSetRGBA (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 3], color, color, color, color);
+
+		float FwdAngle = CGeneral::GetATanOfXY(TheCamera.GetForward().x, TheCamera.GetForward().y);
+		float v = 2.0f * TheCamera.GetForward().z * 0.2f;
+		float u = float(object->m_randomSeed & 15) * 0.02f + (FwdAngle / TWOPI);
+
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 0], u);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 0], v);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 1], u+0.2f);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 1], v);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 2], u);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 2], v+0.2f);
+		RwIm3DVertexSetU    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 3], u+0.2f);
+		RwIm3DVertexSetV    (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 3], v+0.2f);
+
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 0], a.x, a.y, a.z);
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 1], b.x, b.y, b.z);
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 2], c.x, c.y, c.z);
+		RwIm3DVertexSetPos  (&TempBufferRenderVertices[TempBufferVerticesStoredReflection + 3], d.x, d.y, d.z);
+
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 0]  = col->triangles[0].a + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 1]  = col->triangles[0].b + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 2]  = col->triangles[0].c + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 3]  = col->triangles[1].a + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 4]  = col->triangles[1].b + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 5]  = col->triangles[1].c + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 6]  = col->triangles[0].a + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 7]  = col->triangles[0].c + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 8]  = col->triangles[0].b + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 9]  = col->triangles[1].a + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 10] = col->triangles[1].c + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+		TempBufferRenderIndexList[TempBufferIndicesStoredReflection + 11] = col->triangles[1].b + TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET;
+
+		TempBufferIndicesStoredReflection  += 12;
+		TempBufferVerticesStoredReflection += 4;
+	}
+}
+
+int32
+CGlass::CalcAlphaWithNormal(CVector *normal)
+{
+	ASSERT(normal!=nil);
+	
+	float fwdDir = 2.0f * DotProduct(*normal, TheCamera.GetForward());
+	float fwdDot = DotProduct(TheCamera.GetForward()-fwdDir*(*normal), CVector(0.57f, 0.57f, -0.57f));
+	return int32(lerp(fwdDot*fwdDot*fwdDot*fwdDot*fwdDot*fwdDot, 20.0f, 255.0f));
+}
+
+void
+CGlass::RenderHiLightPolys(void)
+{
+	if ( TempBufferVerticesStoredHiLight != TEMPBUFFERVERTHILIGHTOFFSET )
+	{
+		RwRenderStateSet(rwRENDERSTATESRCBLEND,      (void *)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,     (void *)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)RwTextureGetRaster(gpShadowExplosionTex));
+
+		LittleTest();
+
+		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStoredHiLight, nil, rwIM3D_VERTEXUV) )
+		{
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStoredHiLight);
+			RwIm3DEnd();
+		}
+
+		TempBufferVerticesStoredHiLight = TEMPBUFFERVERTHILIGHTOFFSET;
+		TempBufferIndicesStoredHiLight  = TEMPBUFFERINDEXHILIGHTOFFSET;
+	}
+}
+
+void
+CGlass::RenderShatteredPolys(void)
+{
+	if ( TempBufferVerticesStoredShattered != TEMPBUFFERVERTSHATTEREDOFFSET )
+	{
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)RwTextureGetRaster(gpCrackedGlassTex));
+		RwRenderStateSet(rwRENDERSTATESRCBLEND,      (void *)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,     (void *)rwBLENDINVSRCALPHA);
+
+		LittleTest();
+
+		if ( RwIm3DTransform(&TempBufferRenderVertices[TEMPBUFFERVERTSHATTEREDOFFSET], TempBufferVerticesStoredShattered - TEMPBUFFERVERTSHATTEREDOFFSET, nil, rwIM3D_VERTEXUV) )
+		{
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, &TempBufferRenderIndexList[TEMPBUFFERINDEXSHATTEREDOFFSET], TempBufferIndicesStoredShattered - TEMPBUFFERINDEXSHATTEREDOFFSET);
+			RwIm3DEnd();
+		}
+
+		TempBufferIndicesStoredShattered  = TEMPBUFFERINDEXSHATTEREDOFFSET;
+		TempBufferVerticesStoredShattered = TEMPBUFFERVERTSHATTEREDOFFSET;
+	}
+}
+
+void
+CGlass::RenderReflectionPolys(void)
+{
+	if ( TempBufferVerticesStoredReflection != TEMPBUFFERVERTREFLECTIONOFFSET )
+	{
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)RwTextureGetRaster(gpShadowHeadLightsTex));
+		RwRenderStateSet(rwRENDERSTATESRCBLEND,      (void *)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,     (void *)rwBLENDINVSRCALPHA);
+
+		LittleTest();
+
+		if ( RwIm3DTransform(&TempBufferRenderVertices[TEMPBUFFERVERTREFLECTIONOFFSET], TempBufferVerticesStoredReflection - TEMPBUFFERVERTREFLECTIONOFFSET, nil, rwIM3D_VERTEXUV) )
+		{
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, &TempBufferRenderIndexList[TEMPBUFFERINDEXREFLECTIONOFFSET], TempBufferIndicesStoredReflection - TEMPBUFFERINDEXREFLECTIONOFFSET);
+			RwIm3DEnd();
+		}
+
+		TempBufferIndicesStoredReflection  = TEMPBUFFERINDEXREFLECTIONOFFSET;
+		TempBufferVerticesStoredReflection = TEMPBUFFERVERTREFLECTIONOFFSET;
+	}
+}
+
+void
+CGlass::WindowRespondsToCollision(CEntity *entity, float amount, CVector speed, CVector point, bool explosion)
+{
+	ASSERT(entity!=nil);
+	
+	CObject *object = (CObject *)entity;
+
+	if ( object->bGlassBroken )
+		return;
+
+	object->bGlassCracked = true;
+
+	CColModel *col = object->GetColModel();
+	ASSERT(col!=nil);
+	
+	CVector a = object->GetMatrix() * col->vertices[0].Get();
+	CVector b = object->GetMatrix() * col->vertices[1].Get();
+	CVector c = object->GetMatrix() * col->vertices[2].Get();
+	CVector d = object->GetMatrix() * col->vertices[3].Get();
+
+	float minx = Min(Min(a.x, b.x), Min(c.x, d.x));
+	float maxx = Max(Max(a.x, b.x), Max(c.x, d.x));
+	float miny = Min(Min(a.y, b.y), Min(c.y, d.y));
+	float maxy = Max(Max(a.y, b.y), Max(c.y, d.y));
+	float minz = Min(Min(a.z, b.z), Min(c.z, d.z));
+	float maxz = Max(Max(a.z, b.z), Max(c.z, d.z));
+
+
+	if ( amount > 300.0f )
+	{
+		PlayOneShotScriptObject(SCRIPT_SOUND_GLASS_BREAK_L, object->GetPosition());
+
+		GeneratePanesForWindow(0,
+			CVector(minx,      miny,      minz),
+			CVector(0.0f,      0.0f,      maxz-minz),
+			CVector(maxx-minx, maxy-miny, 0.0f),
+			speed, point, 0.1f, !!object->bGlassCracked, explosion);
+	}
+	else
+	{
+		PlayOneShotScriptObject(SCRIPT_SOUND_GLASS_BREAK_S, object->GetPosition());
+
+		GeneratePanesForWindow(1,
+			CVector(minx,      miny,      minz),
+			CVector(0.0f,      0.0f,      maxz-minz),
+			CVector(maxx-minx, maxy-miny, 0.0f),
+			speed, point, 0.1f, !!object->bGlassCracked, explosion);
+	}
+
+	object->bGlassBroken = true;
+	object->GetMatrix().GetPosition().z = -100.0f;
+}
+
+void
+CGlass::WindowRespondsToSoftCollision(CEntity *entity, float amount)
+{
+	ASSERT(entity!=nil);
+	
+	CObject *object = (CObject *)entity;
+
+	if ( amount > 50.0f && !object->bGlassCracked )
+	{
+		PlayOneShotScriptObject(SCRIPT_SOUND_GLASS_CRACK, object->GetPosition());
+		object->bGlassCracked = true;
+	}
+}
+
+void
+CGlass::WasGlassHitByBullet(CEntity *entity, CVector point)
+{
+	ASSERT(entity!=nil);
+	
+	CObject *object = (CObject *)entity;
+
+	if ( IsGlass(object->GetModelIndex()) )
+	{
+		if ( !object->bGlassCracked )
+		{
+			PlayOneShotScriptObject(SCRIPT_SOUND_GLASS_CRACK, object->GetPosition());
+			object->bGlassCracked = true;
+		}
+		else
+		{
+			if ( (CGeneral::GetRandomNumber() & 3) == 2 )
+				WindowRespondsToCollision(object, 0.0f, CVector(0.0f, 0.0f, 0.0f), point, false);
+		}
+	}
+}
+
+void
+CGlass::WindowRespondsToExplosion(CEntity *entity, CVector point)
+{
+	ASSERT(entity!=nil);
+	
+	CObject *object = (CObject *)entity;
+
+	CVector distToGlass = object->GetPosition() - point;
+
+	float fDistToGlass = distToGlass.Magnitude();
+
+	if ( fDistToGlass < 10.0f )
+	{
+		distToGlass *= (0.3f / fDistToGlass); // normalise
+		WindowRespondsToCollision(object, 10000.0f, distToGlass, object->GetPosition(), true);
+	}
+	else
+	{
+		if ( fDistToGlass < 30.0f )
+			object->bGlassCracked = true;
+	}
+}
diff --git a/src/renderer/Glass.h b/src/renderer/Glass.h
new file mode 100644
index 00000000..51c5aae9
--- /dev/null
+++ b/src/renderer/Glass.h
@@ -0,0 +1,52 @@
+#pragma once
+
+class CEntity;
+
+class CFallingGlassPane : public CMatrix
+{
+public:
+	CVector m_vecMoveSpeed;
+	CVector m_vecTurn;
+	uint32 m_nTimer;
+	float m_fGroundZ;
+	float m_fStep;
+	uint8 m_nTriIndex;
+	bool m_bActive;
+	bool m_bShattered;
+
+	CFallingGlassPane()  { }
+	~CFallingGlassPane() { }
+
+	void Update(void);
+	void Render(void);
+};
+
+VALIDATE_SIZE(CFallingGlassPane, 0x70);
+
+enum
+{
+	NUM_GLASSTRIANGLES = 5,
+};
+
+class CGlass
+{
+	static uint32 NumGlassEntities;
+	static CEntity *apEntitiesToBeRendered[NUM_GLASSENTITIES];
+	static CFallingGlassPane aGlassPanes[NUM_GLASSPANES];
+public:
+	static void Init(void);
+	static void Update(void);
+	static void Render(void);
+	static CFallingGlassPane *FindFreePane(void);
+	static void GeneratePanesForWindow(uint32 type, CVector pos, CVector up, CVector right, CVector speed, CVector point, float moveSpeed, bool cracked, bool explosion);
+	static void AskForObjectToBeRenderedInGlass(CEntity *entity);
+	static void RenderEntityInGlass(CEntity *entity);
+	static int32 CalcAlphaWithNormal(CVector *normal);
+	static void RenderHiLightPolys(void);
+	static void RenderShatteredPolys(void);
+	static void RenderReflectionPolys(void);
+	static void WindowRespondsToCollision(CEntity *entity, float amount, CVector speed, CVector point, bool explosion);
+	static void WindowRespondsToSoftCollision(CEntity *entity, float amount);
+	static void WasGlassHitByBullet(CEntity *entity, CVector point);
+	static void WindowRespondsToExplosion(CEntity *entity, CVector point);
+};
\ No newline at end of file
diff --git a/src/renderer/Hud.cpp b/src/renderer/Hud.cpp
new file mode 100644
index 00000000..bba8c525
--- /dev/null
+++ b/src/renderer/Hud.cpp
@@ -0,0 +1,1713 @@
+#include "common.h"
+
+#include "Camera.h"
+#include "DMAudio.h"
+#include "Clock.h"
+#include "Darkel.h"
+#include "Hud.h"
+#include "Messages.h"
+#include "Frontend.h"
+#include "Font.h"
+#include "Pad.h"
+#include "Radar.h"
+#include "Replay.h"
+#include "Wanted.h"
+#include "Sprite.h"
+#include "Sprite2d.h"
+#include "Text.h"
+#include "Timer.h"
+#include "Script.h"
+#include "TxdStore.h"
+#include "User.h"
+#include "World.h"
+
+#ifdef PS2_HUD
+#define MONEY_X 100.0f
+#define WEAPON_X 91.0f
+#define AMMO_X 59.0f
+#define HEALTH_X 100.0f
+#define STARS_X 49.0f
+#define ZONE_Y 61.0f
+#define VEHICLE_Y 81.0f
+#define CLOCK_X 101.0f
+#define SUBS_Y 83.0f
+#define WASTEDBUSTED_Y 122.0f
+#define BIGMESSAGE_Y 80.0f
+#else
+#define MONEY_X 110.0f
+#define WEAPON_X 99.0f
+#define AMMO_X 66.0f
+#define HEALTH_X 110.0f
+#define STARS_X 60.0f
+#define ZONE_Y 30.0f
+#define VEHICLE_Y 55.0f
+#define CLOCK_X 111.0f
+#define SUBS_Y 68.0f
+#define WASTEDBUSTED_Y 82.0f
+#define BIGMESSAGE_Y 84.0f
+#endif
+
+#ifdef FIX_BUGS
+#define TIMER_RIGHT_OFFSET 34.0f // Taken from VC frenzy timer
+#define BIGMESSAGE_Y_OFFSET 18.0f
+#else
+#define TIMER_RIGHT_OFFSET 27.0f
+#define BIGMESSAGE_Y_OFFSET 20.0f
+#endif
+
+#if defined(PS2_HUD) && !defined(FIX_BUGS)
+	#define SCREEN_SCALE_X_PC(a) (a)
+	#define SCREEN_SCALE_Y_PC(a) (a)
+	#define SCALE_AND_CENTER_X_PC(a) (a)
+#else
+	#define SCREEN_SCALE_X_PC(a) SCREEN_SCALE_X(a)
+	#define SCREEN_SCALE_Y_PC(a) SCREEN_SCALE_Y(a)
+	#define SCALE_AND_CENTER_X_PC(a) SCALE_AND_CENTER_X(a)
+#endif
+
+#if defined(FIX_BUGS)
+	#define SCREEN_SCALE_X_FIX(a) SCREEN_SCALE_X(a)
+	#define SCREEN_SCALE_Y_FIX(a) SCREEN_SCALE_Y(a)
+	#define SCALE_AND_CENTER_X_FIX(a) SCALE_AND_CENTER_X(a)
+#else
+	#define SCREEN_SCALE_X_FIX(a) (a)
+	#define SCREEN_SCALE_Y_FIX(a) (a)
+	#define SCALE_AND_CENTER_X_FIX(a) (a)
+#endif
+
+#ifdef FIX_BUGS
+#define FRAMECOUNTER CTimer::GetLogicalFrameCounter()
+#else
+#define FRAMECOUNTER CTimer::GetFrameCounter()
+#endif
+
+// Game has colors inlined in code.
+// For easier modification we collect them here:
+CRGBA MONEY_COLOR(89, 115, 150, 255);
+CRGBA AMMO_COLOR(0, 0, 0, 255);
+CRGBA HEALTH_COLOR(186, 101, 50, 255);
+CRGBA ARMOUR_COLOR(124, 140, 95, 255);
+CRGBA WANTED_COLOR(193, 164, 120, 255);
+CRGBA ZONE_COLOR(152, 154, 82, 255);
+CRGBA VEHICLE_COLOR(194, 165, 120, 255);
+CRGBA CLOCK_COLOR(194, 165, 120, 255);
+CRGBA TIMER_COLOR(186, 101, 50, 255);
+CRGBA COUNTER_COLOR(0, 106, 164, 255);
+CRGBA PAGER_COLOR(32, 162, 66, 205);
+CRGBA RADARDISC_COLOR(0, 0, 0, 255);
+CRGBA BIGMESSAGE_COLOR(85, 119, 133, 255);
+CRGBA WASTEDBUSTED_COLOR(170, 123, 87, 255);
+CRGBA ODDJOB_COLOR(89, 115, 150, 255);
+CRGBA ODDJOB2_COLOR(156, 91, 40, 255);
+CRGBA MISSIONTITLE_COLOR(220, 172, 2, 255);
+
+
+int16 CHud::m_ItemToFlash;
+CSprite2d CHud::Sprites[NUM_HUD_SPRITES];
+wchar *CHud::m_pZoneName;
+wchar *CHud::m_pLastZoneName;
+wchar *CHud::m_ZoneToPrint;
+wchar CHud::m_Message[256];
+wchar CHud::m_BigMessage[6][128];
+wchar LastBigMessage[6][128];
+wchar CHud::m_PagerMessage[256];
+uint32 CHud::m_ZoneNameTimer;
+int32 CHud::m_ZoneFadeTimer;
+uint32 CHud::m_ZoneState;
+wchar CHud::m_HelpMessage[HELP_MSG_LENGTH];
+wchar CHud::m_LastHelpMessage[HELP_MSG_LENGTH];
+wchar CHud::m_HelpMessageToPrint[HELP_MSG_LENGTH];
+uint32 CHud::m_HelpMessageTimer;
+int32 CHud::m_HelpMessageFadeTimer;
+uint32 CHud::m_HelpMessageState;
+bool CHud::m_HelpMessageQuick;
+float CHud::m_HelpMessageDisplayTime;
+int32 CHud::SpriteBrightness;
+bool CHud::m_Wants_To_Draw_Hud;
+bool CHud::m_Wants_To_Draw_3dMarkers;
+wchar *CHud::m_pVehicleName;
+wchar *CHud::m_pLastVehicleName;
+uint32 CHud::m_VehicleNameTimer;
+int32 CHud::m_VehicleFadeTimer;
+uint32 CHud::m_VehicleState;
+wchar *CHud::m_pVehicleNameToPrint;
+
+// These aren't really in CHud
+float BigMessageInUse[6];
+float BigMessageX[6];
+float BigMessageAlpha[6];
+int16 PagerOn;
+int16 PagerTimer;
+float PagerXOffset;
+int16 PagerSoundPlayed;
+int16 OddJob2On;
+uint16 OddJob2Timer;
+float OddJob2XOffset;
+float OddJob2OffTimer;
+bool CounterOnLastFrame;
+uint16 CounterFlashTimer;
+bool TimerOnLastFrame;
+uint16 TimerFlashTimer;
+
+RwTexture *gpSniperSightTex;
+RwTexture *gpRocketSightTex;
+
+struct
+{
+	const char *name;
+	const char *mask;
+} WeaponFilenames[] = {
+	{"fist", "fistm"},
+	{"bat", "batm"},
+	{"pistol", "pistolm" },
+	{"uzi", "uzim"},
+	{"shotgun", "shotgunm"},
+	{"ak47", "ak47m"},
+	{"m16", "m16m"},
+	{"sniper", "sniperm"},
+	{"rocket", "rocketm"},
+	{"flame", "flamem"},
+	{"molotov", "molotovm"},
+	{"grenade", "grenadem"},
+	{"detonator", "detonator_mask"},
+	{"", ""},
+	{"", ""},
+	{"radardisc", "radardisc"},
+	{"pager", "pagerm"},
+	{"", ""},
+	{"", ""},
+	{"bleeder", ""},
+	{"sitesniper", "sitesniperm"},
+	{"siteM16", "siteM16m"},
+	{"siterocket", "siterocket"}
+};
+
+void CHud::Initialise()
+{
+	m_Wants_To_Draw_Hud = true;
+	m_Wants_To_Draw_3dMarkers = true;
+
+	int HudTXD = CTxdStore::AddTxdSlot("hud");
+	CTxdStore::LoadTxd(HudTXD, "MODELS/HUD.TXD");
+	CTxdStore::AddRef(HudTXD);
+	CTxdStore::PopCurrentTxd();
+	CTxdStore::SetCurrentTxd(HudTXD);
+
+	for (int i = 0; i < NUM_HUD_SPRITES; i++) {
+		Sprites[i].SetTexture(WeaponFilenames[i].name, WeaponFilenames[i].mask);
+	}
+
+	GetRidOfAllHudMessages();
+
+	if (gpSniperSightTex == nil)
+		gpSniperSightTex = RwTextureRead("sitesniper", nil);
+	if (gpRocketSightTex == nil)
+		gpRocketSightTex = RwTextureRead("siterocket", nil);
+
+	CounterOnLastFrame = false;
+	m_ItemToFlash = ITEM_NONE;
+	OddJob2Timer = 0;
+	OddJob2OffTimer = 0.0f;
+	OddJob2On = 0;
+	OddJob2XOffset = 0.0f;
+	CounterFlashTimer = 0;
+	TimerOnLastFrame = false;
+	TimerFlashTimer = 0;
+	SpriteBrightness = 0;
+	PagerOn = 0;
+	PagerTimer = 0;
+	PagerSoundPlayed = 0;
+	PagerXOffset = 150.0f;
+
+	CTxdStore::PopCurrentTxd();
+}
+
+void CHud::Shutdown()
+{
+	for (int i = 0; i < NUM_HUD_SPRITES; ++i) {
+		Sprites[i].Delete();
+	}
+
+	RwTextureDestroy(gpSniperSightTex);
+	gpSniperSightTex = nil;
+
+	RwTextureDestroy(gpRocketSightTex);
+	gpRocketSightTex = nil;
+
+	int HudTXD = CTxdStore::FindTxdSlot("hud");
+	CTxdStore::RemoveTxdSlot(HudTXD);
+}
+
+void CHud::ReInitialise() {
+	m_Wants_To_Draw_Hud = true;
+	m_Wants_To_Draw_3dMarkers = true;
+
+	GetRidOfAllHudMessages();
+
+	CounterOnLastFrame = false;
+	m_ItemToFlash = ITEM_NONE;
+	OddJob2Timer = 0;
+	OddJob2OffTimer = 0.0f;
+	OddJob2On = 0;
+	OddJob2XOffset = 0.0f;
+	CounterFlashTimer = 0;
+	TimerOnLastFrame = false;
+	TimerFlashTimer = 0;
+	SpriteBrightness = 0;
+	PagerOn = 0;
+	PagerTimer = 0;
+	PagerSoundPlayed = 0;
+	PagerXOffset = 150.0f;
+}
+
+void CHud::GetRidOfAllHudMessages()
+{
+	m_ZoneState = 0;
+	m_pLastZoneName = nil;
+	m_ZoneNameTimer = 0;
+	m_pZoneName = nil;
+
+	for (int i = 0; i < HELP_MSG_LENGTH; i++) {
+		m_HelpMessage[i] = 0;
+		m_LastHelpMessage[i] = 0;
+		m_HelpMessageToPrint[i] = 0;
+	}
+
+	m_HelpMessageTimer = 0;
+	m_HelpMessageFadeTimer = 0;
+	m_HelpMessageState = 0;
+	m_HelpMessageQuick = 0;
+	m_HelpMessageDisplayTime = 1.0f;
+	m_pVehicleName = nil;
+	m_pLastVehicleName = nil;
+	m_pVehicleNameToPrint = nil;
+	m_VehicleNameTimer = 0;
+	m_VehicleFadeTimer = 0;
+	m_VehicleState = 0;
+
+	for (int i = 0; i < ARRAY_SIZE(m_Message); i++)
+		m_Message[i] = 0;
+
+	for (int i = 0; i < 6; i++) {
+		BigMessageInUse[i] = 0.0f;
+
+		for (int j = 0; j < 128; j++)
+			m_BigMessage[i][j] = 0;
+	}
+}
+
+void CHud::SetZoneName(wchar *name)
+{
+	m_pZoneName = name;
+}
+
+void CHud::SetHelpMessage(wchar *message, bool quick)
+{
+	if (!CReplay::IsPlayingBack()) {
+		CMessages::WideStringCopy(m_HelpMessage, message, HELP_MSG_LENGTH);
+		CMessages::InsertPlayerControlKeysInString(m_HelpMessage);
+
+		for (int i = 0; i < HELP_MSG_LENGTH; i++) {
+			m_LastHelpMessage[i] = 0;
+		}
+
+		m_HelpMessageState = 0;
+		m_HelpMessageQuick = quick;
+	}
+}
+
+void CHud::SetVehicleName(wchar *name)
+{
+	m_pVehicleName = name;
+}
+
+void CHud::Draw()
+{
+	// disable hud via second controller
+	if (CPad::GetPad(1)->GetStartJustDown())
+		m_Wants_To_Draw_Hud = !m_Wants_To_Draw_Hud;
+
+#ifdef GTA_PC
+	if (CReplay::IsPlayingBack())
+		return;
+#endif
+
+	if (m_Wants_To_Draw_Hud && !TheCamera.m_WideScreenOn) {
+		bool DrawCrossHair = false;
+#ifdef GTA_PC
+		bool DrawCrossHairPC = false;
+#endif
+
+		int32 WeaponType = FindPlayerPed()->m_weapons[FindPlayerPed()->m_currentWeapon].m_eWeaponType;
+		int32 Mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
+
+		if (Mode == CCam::MODE_SNIPER || Mode == CCam::MODE_ROCKETLAUNCHER || Mode == CCam::MODE_M16_1STPERSON
+#ifdef GTA_PC
+			|| Mode == CCam::MODE_HELICANNON_1STPERSON
+#endif
+			)
+		{
+			DrawCrossHair = true;
+		}
+		
+#ifdef GTA_PC
+		if (Mode == CCam::MODE_M16_1STPERSON_RUNABOUT || Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT || Mode == CCam::MODE_SNIPER_RUNABOUT)
+			DrawCrossHairPC = true;
+
+		/*
+			Draw Crosshairs
+		*/
+		if (TheCamera.Cams[TheCamera.ActiveCam].Using3rdPersonMouseCam() &&
+		    (!CPad::GetPad(0)->GetLookBehindForPed() || TheCamera.m_bPlayerIsInGarage) || Mode == CCam::MODE_1STPERSON_RUNABOUT) {
+			if (FindPlayerPed() && !FindPlayerPed()->EnteringCar()) {
+				if ((WeaponType >= WEAPONTYPE_COLT45 && WeaponType <= WEAPONTYPE_M16) || WeaponType == WEAPONTYPE_FLAMETHROWER)
+					DrawCrossHairPC = true;
+			}
+		}
+#endif
+
+		if ( DrawCrossHair 
+#ifdef GTA_PC
+			|| DrawCrossHairPC  
+#endif
+			)
+		{
+			RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void *)rwFILTERLINEAR);
+
+			SpriteBrightness = Min(SpriteBrightness+1, 30);
+
+			RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+
+			float fStep = Sin((CTimer::GetTimeInMilliseconds() & 1023)/1024.0f * 6.28f);
+			float fMultBright = SpriteBrightness / 30.0f * (0.25f * fStep + 0.75f);
+			CRect rect;
+#ifdef GTA_PC
+			if (DrawCrossHairPC && TheCamera.Cams[TheCamera.ActiveCam].Using3rdPersonMouseCam()) {
+				float f3rdX = SCREEN_WIDTH * TheCamera.m_f3rdPersonCHairMultX;
+				float f3rdY = SCREEN_HEIGHT * TheCamera.m_f3rdPersonCHairMultY;
+#ifdef ASPECT_RATIO_SCALE
+				f3rdY -= SCREEN_SCALE_Y(2.0f);
+#endif
+				if (FindPlayerPed() && WeaponType == WEAPONTYPE_M16) {
+					rect.left = f3rdX - SCREEN_SCALE_X(32.0f * 0.6f);
+					rect.top = f3rdY - SCREEN_SCALE_Y(32.0f  * 0.6f);
+					rect.right = f3rdX + SCREEN_SCALE_X(32.0f * 0.6f);
+					rect.bottom = f3rdY + SCREEN_SCALE_Y(32.0f  * 0.6f);
+
+					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.0f, 0.0f,  1.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f);
+				}
+				else {
+					rect.left = f3rdX - SCREEN_SCALE_X(32.0f * 0.4f);
+					rect.top = f3rdY - SCREEN_SCALE_Y(32.0f  * 0.4f);
+					rect.right = f3rdX + SCREEN_SCALE_X(32.0f * 0.4f);
+					rect.bottom = f3rdY + SCREEN_SCALE_Y(32.0f  * 0.4f);
+
+					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.0f, 0.0f,  1.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f);
+				}
+			}
+			else
+#endif
+			{
+				if (Mode == CCam::MODE_M16_1STPERSON
+#ifdef GTA_PC
+					|| Mode == CCam::MODE_M16_1STPERSON_RUNABOUT
+					|| Mode == CCam::MODE_HELICANNON_1STPERSON
+#endif
+					)
+				{
+					rect.left = (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(32.0f);
+					rect.top = (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(32.0f);
+					rect.right = (SCREEN_WIDTH / 2) + SCREEN_SCALE_X(32.0f);
+					rect.bottom = (SCREEN_HEIGHT / 2) + SCREEN_SCALE_Y(32.0f);
+					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.0f, 0.0f,  1.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f);
+				}
+#ifdef GTA_PC
+				else if (Mode == CCam::MODE_1STPERSON_RUNABOUT) {
+					rect.left = (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(32.0f * 0.7f);
+					rect.top = (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(32.0f * 0.7f);
+					rect.right = (SCREEN_WIDTH / 2) + SCREEN_SCALE_X(32.0f * 0.7f);
+					rect.bottom = (SCREEN_HEIGHT / 2) + SCREEN_SCALE_Y(32.0f * 0.7f);
+
+					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.0f, 0.0f,  1.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f);
+				}
+#endif
+				else if (Mode == CCam::MODE_ROCKETLAUNCHER
+#ifdef GTA_PC
+					|| Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT
+#endif
+					)
+				{
+					RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+					RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDONE);
+					RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDONE);
+					RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+					RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+					RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpRocketSightTex));
+					CSprite::RenderOneXLUSprite(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 1.0f, SCREEN_SCALE_X_PC(40.0f), SCREEN_SCALE_Y_PC(40.0f), (100.0f * fMultBright), (200.0f * fMultBright), (100.0f * fMultBright), 255, 1.0f, 255);
+				}
+				else {
+					// Sniper
+					rect.left = SCREEN_WIDTH/2 - SCREEN_SCALE_X(210.0f);
+					rect.top = SCREEN_HEIGHT/2 - SCREEN_SCALE_Y(210.0f);
+					rect.right = SCREEN_WIDTH/2;
+					rect.bottom = SCREEN_HEIGHT/2;
+					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.01f, 0.01f,  1.0f, 0.0f,  0.01f, 1.0f,  1.0f, 1.0f);
+
+					rect.left = SCREEN_WIDTH/2;
+					rect.top = SCREEN_HEIGHT/2 - SCREEN_SCALE_Y(210.0f);
+					rect.right = SCREEN_WIDTH/2 + SCREEN_SCALE_X(210.0f);
+					rect.bottom = SCREEN_HEIGHT/2;
+					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.99f, 0.0f,  0.01f, 0.01f,  0.99f, 1.0f,  0.01f, 1.0f);
+
+					rect.left = SCREEN_WIDTH/2 - SCREEN_SCALE_X(210.0f);
+					rect.top = SCREEN_HEIGHT/2;
+					rect.right = SCREEN_WIDTH/2;
+					rect.bottom = SCREEN_HEIGHT/2 + SCREEN_SCALE_Y(210.0f);
+					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.01f, 0.99f,  1.0f, 0.99f,  0.01f, 0.01f,  1.0f, 0.01f);
+
+					rect.left = SCREEN_WIDTH/2;
+					rect.top = SCREEN_HEIGHT/2;
+					rect.right = SCREEN_WIDTH/2 + SCREEN_SCALE_X(210.0f);
+					rect.bottom = SCREEN_HEIGHT/2 + SCREEN_SCALE_Y(210.0f);
+					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255),
+						0.99f, 0.99f,  0.01f, 0.99f,  0.99f, 0.01f,  0.01f, 0.01f);
+				}
+			}
+			RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void *)rwFILTERLINEAR);
+			RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+		}
+		else {
+			SpriteBrightness = 0;
+		}
+
+		/*
+			DrawMoneyCounter
+		*/
+		wchar sPrint[16];
+		wchar sPrintIcon[16];
+		char sTemp[16];
+
+		sprintf(sTemp, "$%08d", CWorld::Players[CWorld::PlayerInFocus].m_nVisibleMoney);
+		AsciiToUnicode(sTemp, sPrint);
+
+		CFont::SetPropOff();
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+		CFont::SetCentreOff();
+		CFont::SetRightJustifyOn();
+		CFont::SetRightJustifyWrap(0.0f);
+		CFont::SetBackGroundOnlyTextOff();
+		CFont::SetFontStyle(FONT_HEADING);
+		CFont::SetPropOff();
+		CFont::SetColor(CRGBA(0, 0, 0, 255));
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(MONEY_X) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(43.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrint);
+		CFont::SetColor(MONEY_COLOR);
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(MONEY_X), SCREEN_SCALE_Y(43.0f), sPrint);
+
+		/*
+			DrawAmmo
+		*/
+		int32 AmmoAmount = CWeaponInfo::GetWeaponInfo(FindPlayerPed()->GetWeapon()->m_eWeaponType)->m_nAmountofAmmunition;
+		int32 AmmoInClip = FindPlayerPed()->m_weapons[FindPlayerPed()->m_currentWeapon].m_nAmmoInClip;
+		int32 TotalAmmo = FindPlayerPed()->m_weapons[FindPlayerPed()->m_currentWeapon].m_nAmmoTotal;
+		int32 Ammo, Clip;
+
+		if (AmmoAmount <= 1 || AmmoAmount >= 1000)
+			sprintf(sTemp, "%d", TotalAmmo);
+		else {
+			if (WeaponType == WEAPONTYPE_FLAMETHROWER) {
+				Clip = AmmoInClip / 10;
+
+				Ammo = Min((TotalAmmo - AmmoInClip) / 10, 9999);
+			}
+			else {
+				Clip = AmmoInClip;
+
+				Ammo = Min(TotalAmmo - AmmoInClip, 9999);
+			}
+
+			sprintf(sTemp, "%d-%d", Ammo, Clip);
+		}
+
+		AsciiToUnicode(sTemp, sPrint);
+
+		/*
+			DrawWeaponIcon
+		*/
+		Sprites[WeaponType].Draw(
+			CRect(
+				SCREEN_SCALE_FROM_RIGHT(WEAPON_X),
+				SCREEN_SCALE_Y(27.0f),
+				SCREEN_SCALE_FROM_RIGHT(WEAPON_X)+SCREEN_SCALE_X(64.0f),
+				SCREEN_SCALE_Y(27.0f)+SCREEN_SCALE_Y(64.0f)),
+			CRGBA(255, 255, 255, 255),
+			0.015f,
+			0.015f,
+			1.0f,
+			0.0f,
+			0.015f,
+			1.0f,
+			1.0f,
+			1.0f);
+		
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X(0.4f), SCREEN_SCALE_Y(0.6f));
+		CFont::SetJustifyOff();
+		CFont::SetCentreOn();
+		CFont::SetCentreSize(SCREEN_WIDTH);
+		CFont::SetPropOn();
+		CFont::SetFontStyle(FONT_BANK);
+
+		if (!CDarkel::FrenzyOnGoing() && WeaponType != WEAPONTYPE_UNARMED && WeaponType != WEAPONTYPE_BASEBALLBAT) {
+			CFont::SetColor(AMMO_COLOR);
+			CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(AMMO_X), SCREEN_SCALE_Y(73.0f), sPrint);
+		}
+
+		/*
+			DrawHealth
+		*/
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+		CFont::SetJustifyOff();
+		CFont::SetCentreOff();
+		CFont::SetRightJustifyWrap(0.0f);
+		CFont::SetRightJustifyOn();
+		CFont::SetPropOff();
+		CFont::SetFontStyle(FONT_HEADING);
+
+		if (m_ItemToFlash == ITEM_HEALTH && FRAMECOUNTER & 8
+			|| m_ItemToFlash != ITEM_HEALTH
+			|| FindPlayerPed()->m_fHealth < 10
+			&& FRAMECOUNTER & 8) {
+			if (FindPlayerPed()->m_fHealth >= 10
+				|| FindPlayerPed()->m_fHealth < 10 && FRAMECOUNTER & 8) {
+
+				AsciiToUnicode("{", sPrintIcon);
+#ifdef FIX_BUGS
+				sprintf(sTemp, "%03d", int32(FindPlayerPed()->m_fHealth + 0.5f));
+#else
+				sprintf(sTemp, "%03d", (int32)FindPlayerPed()->m_fHealth);
+#endif
+				AsciiToUnicode(sTemp, sPrint);
+				CFont::SetColor(CRGBA(0, 0, 0, 255));
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(HEALTH_X) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(65.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrint);
+
+				if (!CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastHealthLoss || CTimer::GetTimeInMilliseconds() > CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastHealthLoss + 2000 || FRAMECOUNTER & 4)
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(HEALTH_X) + SCREEN_SCALE_X_FIX(2.0f) - SCREEN_SCALE_X(56.0f) + SCREEN_SCALE_X(2.0f), SCREEN_SCALE_Y(65.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrintIcon);
+				
+				CFont::SetColor(HEALTH_COLOR);
+
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(HEALTH_X), SCREEN_SCALE_Y(65.0f), sPrint);
+
+				if (!CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastHealthLoss || CTimer::GetTimeInMilliseconds() > CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastHealthLoss + 2000 || FRAMECOUNTER & 4)
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(HEALTH_X) + SCREEN_SCALE_X_FIX(2.0f) - SCREEN_SCALE_X(56.0f), SCREEN_SCALE_Y(65.0f), sPrintIcon);
+			}
+		}
+
+		/*
+			DrawArmour
+		*/
+		if (m_ItemToFlash == ITEM_ARMOUR && FRAMECOUNTER & 8 || m_ItemToFlash != ITEM_ARMOUR) {
+			CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+			if (FindPlayerPed()->m_fArmour > 1.0f) {
+				AsciiToUnicode("[", sPrintIcon);
+#ifdef FIX_BUGS
+				sprintf(sTemp, "%03d", int32(FindPlayerPed()->m_fArmour + 0.5f));
+#else
+				sprintf(sTemp, "%03d", (int32)FindPlayerPed()->m_fArmour);
+#endif
+				AsciiToUnicode(sTemp, sPrint);
+
+				CFont::SetColor(CRGBA(0, 0, 0, 255));
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(182.0f) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(65.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrint);
+
+				if (!CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastArmourLoss || CTimer::GetTimeInMilliseconds() > CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastArmourLoss + 2000 || FRAMECOUNTER & 4)
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(182.0f) + SCREEN_SCALE_X_FIX(2.0f) - SCREEN_SCALE_X(54.0f) + SCREEN_SCALE_X(2.0f), SCREEN_SCALE_Y(65.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrintIcon);
+
+				CFont::SetColor(ARMOUR_COLOR);
+
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(182.0f), SCREEN_SCALE_Y(65.0f), sPrint);
+
+				if (!CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastArmourLoss || CTimer::GetTimeInMilliseconds() > CWorld::Players[CWorld::PlayerInFocus].m_nTimeLastArmourLoss + 2000 || FRAMECOUNTER & 1) {					
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(182.0f) - SCREEN_SCALE_X(54.0f) + SCREEN_SCALE_X(2.0f), SCREEN_SCALE_Y(65.0f), sPrintIcon);
+				}
+			}
+		}
+
+		/*
+			DrawWantedLevel
+		*/
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+		CFont::SetJustifyOff();
+		CFont::SetCentreOff();
+		CFont::SetRightJustifyOff();
+		CFont::SetPropOn();
+		CFont::SetFontStyle(FONT_HEADING);
+
+		AsciiToUnicode("]", sPrintIcon);
+		
+		float fStarsX = SCREEN_SCALE_FROM_RIGHT(STARS_X);
+
+		for (int i = 0; i < 6; i++) {
+			CFont::SetColor(CRGBA(0, 0, 0, 255));
+			CFont::PrintString(fStarsX + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(87.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrintIcon);
+
+			if (FindPlayerPed()->m_pWanted->GetWantedLevel() > i
+				&& (CTimer::GetTimeInMilliseconds() > FindPlayerPed()->m_pWanted->m_nLastWantedLevelChange
+					+ 2000 || FRAMECOUNTER & 4)) {
+
+				CFont::SetColor(WANTED_COLOR);
+				CFont::PrintString(fStarsX, SCREEN_SCALE_Y(87.0f), sPrintIcon);
+			}
+			
+			fStarsX -= SCREEN_SCALE_X(23.0f);
+		}
+
+		/*
+			DrawZoneName
+		*/
+		if (m_pZoneName) {
+			float fZoneAlpha = 255.0f;
+
+			if (m_pZoneName != m_pLastZoneName) {
+				switch (m_ZoneState) {
+				case 0:
+					m_ZoneState = 2;
+					m_ZoneToPrint = m_pZoneName;
+					m_ZoneNameTimer = 0;
+					m_ZoneFadeTimer = 0;
+					break;
+				case 1:
+				case 2:
+				case 3:
+				case 4:
+					m_ZoneNameTimer = 5;
+					m_ZoneState = 4;
+					break;
+				default:
+					break;
+				}
+				m_pLastZoneName = m_pZoneName;
+			}
+
+			if (m_ZoneState) {
+				switch (m_ZoneState) {
+				case 1:
+					m_ZoneFadeTimer = 1000;
+					if (m_ZoneNameTimer > 10000) {
+						m_ZoneFadeTimer = 1000;
+						m_ZoneState = 3;
+					}
+					fZoneAlpha = 255.0f;
+					break;
+				case 2:
+					m_ZoneFadeTimer += CTimer::GetTimeStepInMilliseconds();
+					if (m_ZoneFadeTimer > 1000) {
+						m_ZoneState = 1;
+						m_ZoneFadeTimer = 1000;
+					}
+					fZoneAlpha = m_ZoneFadeTimer / 1000.0f * 255.0f;
+					break;
+				case 3:
+					m_ZoneFadeTimer -= CTimer::GetTimeStepInMilliseconds();
+					if (m_ZoneFadeTimer < 0) {
+						m_ZoneState = 0;
+						m_ZoneFadeTimer = 0;
+					}
+					fZoneAlpha = m_ZoneFadeTimer / 1000.0f * 255.0f;
+					break;
+				case 4:
+					m_ZoneFadeTimer -= CTimer::GetTimeStepInMilliseconds();
+					if (m_ZoneFadeTimer < 0) {
+						m_ZoneFadeTimer = 0;
+						m_ZoneToPrint = m_pLastZoneName;
+						m_ZoneState = 2;
+					}
+					fZoneAlpha = m_ZoneFadeTimer / 1000.0f * 255.0f;
+					break;
+				default:
+					break;
+
+				}
+
+#ifndef HUD_ENHANCEMENTS
+				if (!m_Message[0])
+#else
+				if (!m_Message[0] && !m_BigMessage[2][0]) // Hide zone name if wasted/busted text is displaying
+#endif
+				{
+					m_ZoneNameTimer += CTimer::GetTimeStepInMilliseconds();
+					CFont::SetJustifyOff();
+					CFont::SetPropOn();
+					CFont::SetBackgroundOff();
+
+					if (FrontEndMenuManager.m_PrefsLanguage == CMenuManager::LANGUAGE_SPANISH)
+						CFont::SetScale(SCREEN_SCALE_X(1.2f * 0.8f), SCREEN_SCALE_Y(1.2f));
+					else
+						CFont::SetScale(SCREEN_SCALE_X(1.2f), SCREEN_SCALE_Y(1.2f));
+
+					CFont::SetRightJustifyOn();
+					CFont::SetRightJustifyWrap(0.0f);
+					CFont::SetBackGroundOnlyTextOff();
+					CFont::SetFontStyle(FONT_BANK);
+					CFont::SetColor(CRGBA(0, 0, 0, fZoneAlpha));
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(32.0f) + SCREEN_SCALE_X_FIX(1.0f), SCREEN_SCALE_FROM_BOTTOM(ZONE_Y) + SCREEN_SCALE_Y_FIX(1.0f), m_ZoneToPrint);
+					CFont::SetColor(CRGBA(ZONE_COLOR.r, ZONE_COLOR.g, ZONE_COLOR.b, fZoneAlpha));
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(32.0f), SCREEN_SCALE_FROM_BOTTOM(ZONE_Y), m_ZoneToPrint);
+				}
+			}
+		}
+
+		/*
+			DrawVehicleName
+		*/
+		if (m_pVehicleName) {
+			float fVehicleAlpha = 0.0f;
+
+			if (m_pVehicleName != m_pLastVehicleName) {
+				switch (m_VehicleState) {
+				case 0:
+					m_VehicleState = 2;
+					m_pVehicleNameToPrint = m_pVehicleName;
+					m_VehicleNameTimer = 0;
+					m_VehicleFadeTimer = 0;
+					break;
+				case 1:
+				case 2:
+				case 3:
+				case 4:
+					m_VehicleNameTimer = 0;
+					m_VehicleState = 4;
+					break;
+				default:
+					break;
+				}
+				m_pLastVehicleName = m_pVehicleName;
+			}
+
+			if (m_VehicleState) {
+				switch (m_VehicleState) {
+				case 1:
+					if (m_VehicleNameTimer > 10000) {
+						m_VehicleFadeTimer = 1000;
+						m_VehicleState = 3;
+					}
+					fVehicleAlpha = 255.0f;
+					break;
+				case 2:
+					m_VehicleFadeTimer += CTimer::GetTimeStepInMilliseconds();
+					if (m_VehicleFadeTimer > 1000) {
+						m_VehicleState = 1;
+						m_VehicleFadeTimer = 1000;
+					}
+					fVehicleAlpha = m_VehicleFadeTimer / 1000.0f * 255.0f;
+					break;
+				case 3:
+					m_VehicleFadeTimer -= CTimer::GetTimeStepInMilliseconds();
+					if (m_VehicleFadeTimer < 0) {
+						m_VehicleState = 0;
+						m_VehicleFadeTimer = 0;
+					}
+					fVehicleAlpha = m_VehicleFadeTimer / 1000.0f * 255.0f;
+					break;
+				case 4:
+					m_VehicleFadeTimer -= CTimer::GetTimeStepInMilliseconds();
+					if (m_VehicleFadeTimer < 0) {
+						m_VehicleFadeTimer = 0;
+						m_pVehicleNameToPrint = m_pLastVehicleName;
+						m_VehicleNameTimer = 0;
+						m_VehicleState = 2;
+					}
+					fVehicleAlpha = m_VehicleFadeTimer / 1000.0f * 255.0f;
+					break;
+				default:
+					break;
+				}
+
+#ifndef HUD_ENHANCEMENTS
+				if (!m_Message[0])
+#else
+				if (!m_Message[0] && !m_BigMessage[2][0]) // Hide vehicle name if wasted/busted text is displaying
+#endif
+				{
+					m_VehicleNameTimer += CTimer::GetTimeStepInMilliseconds();
+					CFont::SetJustifyOff();
+					CFont::SetPropOn();
+					CFont::SetBackgroundOff();
+
+					if (FrontEndMenuManager.m_PrefsLanguage != CMenuManager::LANGUAGE_ITALIAN && FrontEndMenuManager.m_PrefsLanguage != CMenuManager::LANGUAGE_SPANISH)
+						CFont::SetScale(SCREEN_SCALE_X(1.2f), SCREEN_SCALE_Y(1.2f));
+					else
+						CFont::SetScale(SCREEN_SCALE_X(1.2f * 0.85f), SCREEN_SCALE_Y(1.2f));
+
+					CFont::SetRightJustifyOn();
+					CFont::SetRightJustifyWrap(0.0f);
+					CFont::SetBackGroundOnlyTextOff();
+					CFont::SetFontStyle(FONT_BANK);
+					CFont::SetColor(CRGBA(0, 0, 0, fVehicleAlpha));
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(32.0f) + SCREEN_SCALE_X_FIX(1.0f), SCREEN_SCALE_FROM_BOTTOM(VEHICLE_Y) + SCREEN_SCALE_Y_FIX(1.0f), m_pVehicleNameToPrint);
+					CFont::SetColor(CRGBA(VEHICLE_COLOR.r, VEHICLE_COLOR.g, VEHICLE_COLOR.b, fVehicleAlpha));
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(32.0f), SCREEN_SCALE_FROM_BOTTOM(VEHICLE_Y), m_pVehicleNameToPrint);
+				}
+			}
+		}
+		else {
+			m_pLastVehicleName = nil;
+			m_VehicleState = 0;
+			m_VehicleFadeTimer = 0;
+			m_VehicleNameTimer = 0;
+		}
+
+		/*
+			DrawClock
+		*/
+		CFont::SetJustifyOff();
+		CFont::SetCentreOff();
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+		CFont::SetBackGroundOnlyTextOff();
+		CFont::SetPropOff();
+		CFont::SetFontStyle(FONT_HEADING);
+		CFont::SetRightJustifyOn();
+		CFont::SetRightJustifyWrap(0.0f);
+
+		sprintf(sTemp, "%02d:%02d", CClock::GetHours(), CClock::GetMinutes());
+		AsciiToUnicode(sTemp, sPrint);
+
+		CFont::SetColor(CRGBA(0, 0, 0, 255));
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(CLOCK_X) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(22.0f) + SCREEN_SCALE_Y_FIX(2.0f), sPrint);
+		CFont::SetColor(CLOCK_COLOR);
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(CLOCK_X), SCREEN_SCALE_Y(22.0f), sPrint);
+
+		/*
+			DrawOnScreenTimer
+		*/
+		wchar sTimer[16];
+
+		if (!CUserDisplay::OnscnTimer.m_sEntries[0].m_bTimerProcessed)
+			TimerOnLastFrame = false;
+		if (!CUserDisplay::OnscnTimer.m_sEntries[0].m_bCounterProcessed)
+			CounterOnLastFrame = false;
+
+		if (CUserDisplay::OnscnTimer.m_bProcessed) {
+			if (CUserDisplay::OnscnTimer.m_sEntries[0].m_bTimerProcessed) {
+				if (!TimerOnLastFrame)
+					TimerFlashTimer = 1;
+
+				TimerOnLastFrame = true;
+
+				if (TimerFlashTimer) {
+					if (++TimerFlashTimer > 50)
+						TimerFlashTimer = 0;
+				}
+
+				if (FRAMECOUNTER & 4 || !TimerFlashTimer) {
+					AsciiToUnicode(CUserDisplay::OnscnTimer.m_sEntries[0].m_bTimerBuffer, sTimer);
+					CFont::SetPropOn();
+					CFont::SetBackgroundOff();
+					CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+					CFont::SetRightJustifyOn();
+					CFont::SetRightJustifyWrap(0.0f);
+					CFont::SetFontStyle(FONT_LOCALE(FONT_HEADING));
+					CFont::SetPropOff();
+					CFont::SetBackGroundOnlyTextOn();
+					CFont::SetColor(CRGBA(0, 0, 0, 255));
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(110.0f) + SCREEN_SCALE_Y_FIX(2.0f), sTimer);
+					CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+					CFont::SetColor(TIMER_COLOR);
+					CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET), SCREEN_SCALE_Y(110.0f), sTimer);
+
+					if (CUserDisplay::OnscnTimer.m_sEntries[0].m_aTimerText[0]) {
+						CFont::SetPropOn();
+						CFont::SetColor(CRGBA(0, 0, 0, 255));
+						CFont::SetScale(SCREEN_SCALE_X(0.8f * 0.8f), SCREEN_SCALE_Y(1.35f));
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(80.0f) + SCREEN_SCALE_X(2.0f), SCREEN_SCALE_Y(110.0f) + SCREEN_SCALE_Y_FIX(2.0f), TheText.Get(CUserDisplay::OnscnTimer.m_sEntries[0].m_aTimerText));
+						CFont::SetColor(TIMER_COLOR);
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(80.0f), SCREEN_SCALE_Y(110.0f), TheText.Get(CUserDisplay::OnscnTimer.m_sEntries[0].m_aTimerText));
+					}
+				}
+			}
+			if (CUserDisplay::OnscnTimer.m_sEntries[0].m_bCounterProcessed) {
+				if (!CounterOnLastFrame)
+					CounterFlashTimer = 1;
+
+				CounterOnLastFrame = true;
+
+				if (CounterFlashTimer) {
+					if (++CounterFlashTimer > 50)
+						CounterFlashTimer = 0;
+				}
+
+				if (FRAMECOUNTER & 4 || !CounterFlashTimer) {
+					if (CUserDisplay::OnscnTimer.m_sEntries[0].m_nType == COUNTER_DISPLAY_NUMBER) {
+						AsciiToUnicode(CUserDisplay::OnscnTimer.m_sEntries[0].m_bCounterBuffer, sTimer);
+						CFont::SetPropOn();
+						CFont::SetBackgroundOff();
+						CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+						CFont::SetCentreOff();
+						CFont::SetRightJustifyOn();
+						CFont::SetRightJustifyWrap(0.0f);
+						CFont::SetFontStyle(FONT_LOCALE(FONT_HEADING));
+						CFont::SetColor(CRGBA(244, 20, 20, 255));
+						CFont::SetWrapx(SCREEN_STRETCH_X(DEFAULT_SCREEN_WIDTH));
+						CFont::SetPropOff();
+						CFont::SetBackGroundOnlyTextOn();
+						CFont::SetColor(CRGBA(0, 0, 0, 255));
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y_FIX(2.0f), sTimer);
+						CFont::SetColor(COUNTER_COLOR);
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET), SCREEN_SCALE_Y(132.0f), sTimer);
+					} else {
+						int counter = atoi(CUserDisplay::OnscnTimer.m_sEntries[0].m_bCounterBuffer);
+#ifdef FIX_BUGS
+						counter = Min(counter, 100);
+#endif
+						CSprite2d::DrawRect
+						(
+							CRect
+							(
+								SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(100.0f) / 2 + SCREEN_SCALE_X_FIX(4.0f),
+								SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y(8.0f),
+								SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) + SCREEN_SCALE_X_FIX(4.0f),
+								SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y_PC(11.0f) + SCREEN_SCALE_Y(8.0f)
+							),
+							CRGBA(0, 106, 164, 80)
+						);
+						
+						CSprite2d::DrawRect
+						(
+							CRect
+							(
+								SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(100.0f) / 2 + SCREEN_SCALE_X_FIX(4.0f), 
+								SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y(8.0f),
+								SCREEN_SCALE_X_PC((float)counter) / 2.0f + SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(100.0f) / 2.0f + SCREEN_SCALE_X_FIX(4.0f),
+								SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y_PC(11.0f) + SCREEN_SCALE_Y(8.0f)
+							),
+							CRGBA(0, 106, 164, 255)
+						);
+					}
+
+					if (CUserDisplay::OnscnTimer.m_sEntries[0].m_aCounterText[0]) {
+						CFont::SetPropOn();
+						CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+						CFont::SetColor(CRGBA(0, 0, 0, 255));
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(61.0f) + SCREEN_SCALE_X(2.0f), SCREEN_SCALE_Y(132.0f) + SCREEN_SCALE_Y_FIX(2.0f), TheText.Get(CUserDisplay::OnscnTimer.m_sEntries[0].m_aCounterText));
+						CFont::SetColor(COUNTER_COLOR);
+						CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(TIMER_RIGHT_OFFSET) - SCREEN_SCALE_X(61.0f), SCREEN_SCALE_Y(132.0f), TheText.Get(CUserDisplay::OnscnTimer.m_sEntries[0].m_aCounterText));
+					}
+				}
+			}
+		}
+
+		/////////////////////////////////
+		/*
+			DrawPager
+		*/
+		if (!m_PagerMessage[0] && PagerOn == 1) {
+			PagerSoundPlayed = false;
+			PagerOn = 2;
+		}
+		if (m_PagerMessage[0] || PagerOn == 2) {
+			if (!PagerOn) {
+				PagerOn = 1;
+				PagerXOffset = 150.0f;
+			}
+			if (PagerOn == 1) {
+				if (PagerXOffset > 0.0f) {
+					float fStep = PagerXOffset * 0.1f;
+					if (fStep > 10.0f)
+						fStep = 10.0f;
+					PagerXOffset -= fStep * CTimer::GetTimeStep();
+				}
+				if (!PagerSoundPlayed) {
+					DMAudio.PlayFrontEndSound(SOUND_PAGER, 0);
+					PagerSoundPlayed = 1;
+				}
+			}
+			else if (PagerOn == 2) {
+				float fStep = PagerXOffset * 0.1f;
+				if (fStep < 2.0f)
+					fStep = 2.0f;
+				PagerXOffset += fStep;
+				if (PagerXOffset > 150.0f) {
+					PagerXOffset = 150.0f;
+					PagerOn = 0;
+				}
+			}
+			Sprites[HUD_PAGER].Draw(CRect(SCREEN_SCALE_X(26.0f) - SCREEN_SCALE_X_FIX(PagerXOffset), SCREEN_SCALE_Y(27.0f), SCREEN_SCALE_X(160.0f) + SCREEN_SCALE_X(26.0f) - SCREEN_SCALE_X_FIX(PagerXOffset), SCREEN_SCALE_Y(80.0f) + SCREEN_SCALE_Y(27.0f)), CRGBA(255, 255, 255, 255));		
+			CFont::SetBackgroundOff();
+			CFont::SetScale(SCREEN_SCALE_X(0.84f), SCREEN_SCALE_Y(1.0f));
+			CFont::SetColor(PAGER_COLOR);
+			CFont::SetRightJustifyOff();
+			CFont::SetBackgroundOff();
+			CFont::SetCentreOff();
+			CFont::SetWrapx(SCREEN_STRETCH_X(DEFAULT_SCREEN_WIDTH));
+			CFont::SetJustifyOff();
+			CFont::SetPropOff();
+			CFont::SetFontStyle(FONT_PAGER);
+			CFont::PrintString(SCREEN_SCALE_X(52.0f) - SCREEN_SCALE_X_FIX(PagerXOffset), SCREEN_SCALE_Y(54.0f), m_PagerMessage);
+		}
+
+		/*
+			DrawRadar
+		*/
+		if (m_ItemToFlash == ITEM_RADAR && FRAMECOUNTER & 8 || m_ItemToFlash != ITEM_RADAR) {
+			CRadar::DrawMap();
+			CRect rect(0.0f, 0.0f, SCREEN_SCALE_X(RADAR_WIDTH), SCREEN_SCALE_Y(RADAR_HEIGHT));
+			rect.Translate(SCREEN_SCALE_X_FIX(RADAR_LEFT), SCREEN_SCALE_FROM_BOTTOM(RADAR_BOTTOM + RADAR_HEIGHT));
+
+#ifdef PS2_HUD
+	#ifdef FIX_BUGS
+			rect.Grow(SCREEN_SCALE_X(2.0f), SCREEN_SCALE_X(4.0f), SCREEN_SCALE_Y(2.0f), SCREEN_SCALE_Y(4.0f));
+	#else
+			rect.Grow(2.0f, 4.0f);
+	#endif
+#else
+	#ifdef FIX_BUGS
+			rect.Grow(SCREEN_SCALE_X(4.0f), SCREEN_SCALE_X(4.0f), SCREEN_SCALE_Y(4.0f), SCREEN_SCALE_Y(4.0f));
+	#else
+			rect.Grow(4.0f);
+	#endif
+#endif
+			Sprites[HUD_RADARDISC].Draw(rect, RADARDISC_COLOR);
+			CRadar::DrawBlips();
+		}
+	}
+
+	/*
+		Draw3dMarkers
+	*/
+	if (m_Wants_To_Draw_3dMarkers && !TheCamera.m_WideScreenOn && !m_BigMessage[0][0] && !m_BigMessage[2][0]) {
+		CRadar::Draw3dMarkers();
+	}
+
+	/*
+		DrawScriptText
+	*/
+	if (!CTimer::GetIsUserPaused()) {
+		for (int i = 0; i < ARRAY_SIZE(CTheScripts::IntroTextLines); i++) {
+			if (CTheScripts::IntroTextLines[i].m_Text[0] && CTheScripts::IntroTextLines[i].m_bTextBeforeFade) {
+				CFont::SetScale(SCREEN_SCALE_X_PC(CTheScripts::IntroTextLines[i].m_fScaleX), SCREEN_SCALE_Y_PC(CTheScripts::IntroTextLines[i].m_fScaleY) 
+#if !defined(PS2_HUD) || defined(FIX_BUGS)
+					* 0.5f
+#endif
+				);
+
+				CFont::SetColor(CTheScripts::IntroTextLines[i].m_sColor);
+
+				if (CTheScripts::IntroTextLines[i].m_bJustify)
+					CFont::SetJustifyOn();
+				else
+					CFont::SetJustifyOff();
+
+				if (CTheScripts::IntroTextLines[i].m_bRightJustify)
+					CFont::SetRightJustifyOn();
+				else
+					CFont::SetRightJustifyOff();
+
+				if (CTheScripts::IntroTextLines[i].m_bCentered)
+					CFont::SetCentreOn();
+				else
+					CFont::SetCentreOff();
+
+				CFont::SetWrapx(SCALE_AND_CENTER_X_PC(CTheScripts::IntroTextLines[i].m_fWrapX));
+				
+				CFont::SetCentreSize(SCREEN_SCALE_X_PC(CTheScripts::IntroTextLines[i].m_fCenterSize));
+				
+				if (CTheScripts::IntroTextLines[i].m_bBackground)
+					CFont::SetBackgroundOn();
+				else
+					CFont::SetBackgroundOff();
+
+				CFont::SetBackgroundColor(CTheScripts::IntroTextLines[i].m_sBackgroundColor);
+
+				if (CTheScripts::IntroTextLines[i].m_bBackgroundOnly)
+					CFont::SetBackGroundOnlyTextOn();
+				else
+					CFont::SetBackGroundOnlyTextOff();
+
+				if (CTheScripts::IntroTextLines[i].m_bTextProportional)
+					CFont::SetPropOn();
+				else
+					CFont::SetPropOff();
+
+				CFont::SetFontStyle(FONT_LOCALE(CTheScripts::IntroTextLines[i].m_nFont));
+				
+#if defined(PS2_HUD) && !defined(FIX_BUGS)
+				CFont::PrintString(CTheScripts::IntroTextLines[i].m_fAtX, CTheScripts::IntroTextLines[i].m_fAtY, CTheScripts::IntroTextLines[i].m_Text);
+#else
+				CFont::PrintString(SCALE_AND_CENTER_X(DEFAULT_SCREEN_WIDTH - CTheScripts::IntroTextLines[i].m_fAtX), SCREEN_SCALE_Y(DEFAULT_SCREEN_HEIGHT - CTheScripts::IntroTextLines[i].m_fAtY), CTheScripts::IntroTextLines[i].m_Text);
+#endif
+			}
+		}
+		for (int i = 0; i < ARRAY_SIZE(CTheScripts::IntroRectangles); i++) {
+			intro_script_rectangle &IntroRect = CTheScripts::IntroRectangles[i];
+
+			// Yeah, top and bottom changed place. R* vision
+			if (IntroRect.m_bIsUsed && IntroRect.m_bBeforeFade) {
+				if (IntroRect.m_nTextureId >= 0) {
+					CRect rect (
+						IntroRect.m_sRect.left,
+						IntroRect.m_sRect.bottom,
+						IntroRect.m_sRect.right,
+						IntroRect.m_sRect.top );
+
+					CTheScripts::ScriptSprites[IntroRect.m_nTextureId].Draw(rect, IntroRect.m_sColor);
+				}
+				else {
+					CRect rect (
+						IntroRect.m_sRect.left,
+						IntroRect.m_sRect.bottom,
+						IntroRect.m_sRect.right,
+						IntroRect.m_sRect.top );
+
+					CSprite2d::DrawRect(rect, IntroRect.m_sColor);
+				}
+			}
+		}
+
+		/*
+			DrawSubtitles
+		*/
+		if (m_Message[0] && !m_BigMessage[2][0] && (FrontEndMenuManager.m_PrefsShowSubtitles == 1 || !TheCamera.m_WideScreenOn)) {
+			CFont::SetJustifyOff();
+			CFont::SetBackgroundOff();
+			CFont::SetBackgroundColor(CRGBA(0, 0, 0, 128));
+			CFont::SetScale(SCREEN_SCALE_X_PC(0.48f), SCREEN_SCALE_Y_PC(1.12f));
+			CFont::SetCentreOn();
+			CFont::SetPropOn();
+			CFont::SetFontStyle(FONT_LOCALE(FONT_BANK));
+
+#ifdef XBOX_SUBTITLES
+			float radarBulge = SCREEN_SCALE_X(45.0f) + SCREEN_SCALE_X(16.0f);
+			float rectWidth = SCREEN_WIDTH - SCREEN_SCALE_X(45.0f) - SCREEN_SCALE_X(16.0f) - radarBulge;
+			CFont::SetCentreSize(rectWidth);
+			CFont::SetColor(CRGBA(180, 180, 180, 255));
+
+			CFont::PrintOutlinedString(rectWidth / 2.0f + radarBulge, SCREEN_SCALE_Y(4.0f) + SCREEN_SCALE_FROM_BOTTOM(48.0f) - SCREEN_SCALE_Y(1), m_Message,
+				2.0f, true, CRGBA(0, 0, 0, 255));
+#else
+			float radarBulge = SCREEN_SCALE_X(40.0f) + SCREEN_SCALE_X(8.0f);
+			float rectWidth = SCREEN_SCALE_FROM_RIGHT(50.0f) - SCREEN_SCALE_X(8.0f) - radarBulge;
+			
+			CFont::SetCentreSize(rectWidth);
+
+			const int16 shadow = 1;
+			CFont::SetDropShadowPosition(shadow);
+			CFont::SetDropColor(CRGBA(0, 0, 0, 255));
+			CFont::SetColor(CRGBA(235, 235, 235, 255));
+
+			// I'm not sure shadow substaction was intentional here, might be a leftover if CFont::PrintString was used for a shadow draw call
+			CFont::PrintString(rectWidth / 2.0f + radarBulge - SCREEN_SCALE_X_FIX(shadow), SCREEN_SCALE_Y_PC(4.0f) + SCREEN_SCALE_FROM_BOTTOM(SUBS_Y) - SCREEN_SCALE_Y_FIX(shadow), m_Message);
+			CFont::SetDropShadowPosition(0);
+#endif // #ifdef XBOX_SUBTITLES
+		}
+
+		/*
+			DrawBigMessage
+		*/
+		// MissionCompleteFailedText
+		if (m_BigMessage[0][0]) {
+			if (BigMessageInUse[0] != 0.0f) {
+				CFont::SetJustifyOff();
+				CFont::SetBackgroundOff();
+				CFont::SetBackGroundOnlyTextOff();
+				
+				if (CGame::frenchGame || CGame::germanGame)
+					CFont::SetScale(SCREEN_SCALE_X_PC(1.8f), SCREEN_SCALE_Y_PC(1.8f));
+				else
+					CFont::SetScale(SCREEN_SCALE_X_PC(1.8f), SCREEN_SCALE_Y_PC(1.8f));
+				
+				CFont::SetPropOn();
+				CFont::SetCentreOn();
+				CFont::SetCentreSize(SCREEN_SCALE_X(DEFAULT_SCREEN_WIDTH - 25));
+				CFont::SetColor(CRGBA(255, 255, 0, 255));
+				CFont::SetFontStyle(FONT_HEADING);
+
+				// Appearently sliding text in here was abandoned very early, since this text is centered now.
+#ifdef FIX_BUGS
+				if (BigMessageX[0] >= SCALE_AND_CENTER_X(DEFAULT_SCREEN_WIDTH-20))
+#else
+				if (BigMessageX[0] >= SCREEN_WIDTH-20)
+#endif
+				{
+					BigMessageInUse[0] += CTimer::GetTimeStep();
+
+					if (BigMessageInUse[0] >= 120.0f) {
+						BigMessageInUse[0] = 120.0f;
+						BigMessageAlpha[0] -= (CTimer::GetTimeStepInMilliseconds() * 0.3f);
+					}
+
+					if (BigMessageAlpha[0] <= 0.0f) {
+						m_BigMessage[0][0] = 0;
+						BigMessageAlpha[0] = 0.0f;
+					}
+				}
+				else {
+					BigMessageX[0] += SCREEN_SCALE_X_FIX(CTimer::GetTimeStepInMilliseconds() * 0.3f);
+					BigMessageAlpha[0] += (CTimer::GetTimeStepInMilliseconds() * 0.3f);
+
+					if (BigMessageAlpha[0] > 255.0f)
+						BigMessageAlpha[0] = 255.0f;
+				}
+				CFont::SetColor(CRGBA(0, 0, 0, BigMessageAlpha[0]));
+
+#if defined(PS2_HUD) && !defined(FIX_BUGS) // yeah, that's right. ps2 uses y=ScaleX(a)
+				CFont::PrintString(SCREEN_WIDTH / 2 + SCREEN_SCALE_X_FIX(2.0f), (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(120.0f) + SCREEN_SCALE_Y_FIX(2.0f), m_BigMessage[0]);
+#else
+				CFont::PrintString(SCREEN_WIDTH / 2 + SCREEN_SCALE_X_FIX(2.0f), (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(BIGMESSAGE_Y_OFFSET) + SCREEN_SCALE_Y_FIX(2.0f), m_BigMessage[0]);
+#endif
+				CFont::SetColor(CRGBA(BIGMESSAGE_COLOR.r, BIGMESSAGE_COLOR.g, BIGMESSAGE_COLOR.b, BigMessageAlpha[0]));
+#if defined(PS2_HUD) && !defined(FIX_BUGS) // same
+				CFont::PrintString(SCREEN_WIDTH / 2, (SCREEN_WIDTH  / 2) - SCREEN_SCALE_X(120.0f), m_BigMessage[0]);
+#else
+				CFont::PrintString(SCREEN_WIDTH / 2, (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(18.0f), m_BigMessage[0]);
+#endif
+			}
+			else {
+				BigMessageAlpha[0] = 0.0f;
+				BigMessageX[0] = SCALE_AND_CENTER_X_FIX(-60.0f);
+				BigMessageInUse[0] = 1.0f;
+			}
+		}
+		else {
+			BigMessageInUse[0] = 0.0f;
+		}
+
+		// WastedBustedText
+		if (m_BigMessage[2][0]) {
+			if (BigMessageInUse[2] != 0.0f) {
+				BigMessageAlpha[2] += (CTimer::GetTimeStepInMilliseconds() * 0.4f);
+
+				if (BigMessageAlpha[2] > 255.0f)
+					BigMessageAlpha[2] = 255.0f;
+
+				CFont::SetBackgroundOff();
+
+				if (CGame::frenchGame || CGame::germanGame)
+					CFont::SetScale(SCREEN_SCALE_X_PC(1.4f), SCREEN_SCALE_Y_PC(1.4f));
+				else
+					CFont::SetScale(SCREEN_SCALE_X_PC(2.0f), SCREEN_SCALE_Y_PC(2.0f));
+
+				CFont::SetPropOn();
+				CFont::SetRightJustifyOn();
+				CFont::SetFontStyle(FONT_HEADING);
+
+				CFont::SetColor(CRGBA(0, 0, 0, BigMessageAlpha[2]*0.75f));
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(20.0f) + SCREEN_SCALE_X_FIX(4.0f), SCREEN_SCALE_FROM_BOTTOM(WASTEDBUSTED_Y) + SCREEN_SCALE_Y(4.0f), m_BigMessage[2]);
+				CFont::SetColor(CRGBA(WASTEDBUSTED_COLOR.r, WASTEDBUSTED_COLOR.g, WASTEDBUSTED_COLOR.b, BigMessageAlpha[2]));
+				CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(20.0f), SCREEN_SCALE_FROM_BOTTOM(WASTEDBUSTED_Y), m_BigMessage[2]);
+			}
+			else {
+				BigMessageAlpha[2] = 0.0f;
+				BigMessageInUse[2] = 1.0f;
+			}
+		}
+		else {
+			BigMessageInUse[2] = 0.0f;
+		}
+	}
+}
+
+void CHud::DrawAfterFade()
+{
+	if (CTimer::GetIsUserPaused() || CReplay::IsPlayingBack())
+		return;
+
+	if (m_HelpMessage[0]) {
+		if (!CMessages::WideStringCompare(m_HelpMessage, m_LastHelpMessage, HELP_MSG_LENGTH)) {
+			switch (m_HelpMessageState) {
+			case 0:
+				m_HelpMessageFadeTimer = 0;
+				m_HelpMessageState = 2;
+				m_HelpMessageTimer = 0;
+				CMessages::WideStringCopy(m_HelpMessageToPrint, m_HelpMessage, HELP_MSG_LENGTH);
+				m_HelpMessageDisplayTime = CMessages::GetWideStringLength(m_HelpMessage) / 20.0f + 3.0f;
+
+				if (TheCamera.m_ScreenReductionPercentage == 0.0f)
+					DMAudio.PlayFrontEndSound(SOUND_HUD, 0);
+				break;
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+				m_HelpMessageTimer = 5;
+				m_HelpMessageState = 4;
+				break;
+			default:
+				break;
+			}
+			CMessages::WideStringCopy(m_LastHelpMessage, m_HelpMessage, HELP_MSG_LENGTH);
+		}
+
+		float fAlpha = 225.0f;
+
+		if (m_HelpMessageState != 0) {
+			switch (m_HelpMessageState) {
+			case 1:
+				fAlpha = 225.0f;
+				m_HelpMessageFadeTimer = 600;
+				if (m_HelpMessageTimer > m_HelpMessageDisplayTime * 1000.0f || m_HelpMessageQuick && m_HelpMessageTimer > 1500.0f) {
+					m_HelpMessageFadeTimer = 600;
+					m_HelpMessageState = 3;
+				}
+				break;
+			case 2:
+				m_HelpMessageFadeTimer += 2 * CTimer::GetTimeStepInMilliseconds();
+				if (m_HelpMessageFadeTimer > 0) {
+					m_HelpMessageState = 1;
+					m_HelpMessageFadeTimer = 0;
+				}
+				fAlpha = m_HelpMessageFadeTimer / 1000.0f * 225.0f;
+				break;
+			case 3:
+				m_HelpMessageFadeTimer -= 2 * CTimer::GetTimeStepInMilliseconds();
+				if (m_HelpMessageFadeTimer < 0) {
+					m_HelpMessageState = 0;
+					m_HelpMessageFadeTimer = 0;
+				}
+				fAlpha = m_HelpMessageFadeTimer / 1000.0f * 225.0f;
+				break;
+			case 4:
+				m_HelpMessageFadeTimer -= 2 * CTimer::GetTimeStepInMilliseconds();
+				if (m_HelpMessageFadeTimer < 0) {
+					m_HelpMessageState = 2;
+					m_HelpMessageFadeTimer = 0;
+					CMessages::WideStringCopy(m_HelpMessageToPrint, m_LastHelpMessage, HELP_MSG_LENGTH);
+				}
+				fAlpha = m_HelpMessageFadeTimer / 1000.0f * 225.0f;
+				break;
+			default:
+				break;
+			}
+
+			m_HelpMessageTimer += CTimer::GetTimeStepInMilliseconds();
+
+			CFont::SetAlphaFade(fAlpha);
+			CFont::SetCentreOff();
+			CFont::SetPropOn();
+
+			if (CGame::germanGame)
+				CFont::SetScale(SCREEN_SCALE_X(0.52f * 0.85f), SCREEN_SCALE_Y(1.1f * 0.85f));
+#ifdef MORE_LANGUAGES
+			else if (CFont::IsJapanese())
+				CFont::SetScale(SCREEN_SCALE_X(0.52f) * 1.35f, SCREEN_SCALE_Y(1.1f) * 1.25f);
+#endif
+			else
+				CFont::SetScale(SCREEN_SCALE_X(0.52f), SCREEN_SCALE_Y(1.1f));
+
+			CFont::SetColor(CRGBA(175, 175, 175, 255));
+			CFont::SetJustifyOff();			
+#ifdef MORE_LANGUAGES
+			if (CFont::IsJapanese())
+				CFont::SetWrapx(SCREEN_SCALE_X(229.0f) + SCREEN_SCALE_X(26.0f) - SCREEN_SCALE_X_FIX(4.0f));
+			else
+#endif
+				CFont::SetWrapx(SCREEN_SCALE_X(200.0f) + SCREEN_SCALE_X(26.0f) - SCREEN_SCALE_X_FIX(4.0f));
+			CFont::SetFontStyle(FONT_LOCALE(FONT_BANK));
+			CFont::SetBackgroundOn();
+			CFont::SetBackGroundOnlyTextOff();
+			CFont::SetBackgroundColor(CRGBA(0, 0, 0, fAlpha * 0.9f));
+			CFont::SetColor(CRGBA(175, 175, 175, 255));
+			CFont::PrintString(SCREEN_SCALE_X(26.0f), SCREEN_SCALE_Y(28.0f) + SCREEN_SCALE_Y_FIX((150.0f - PagerXOffset) * 0.6f), m_HelpMessageToPrint);
+			CFont::SetAlphaFade(255.0f);
+		}
+	}
+
+	for (int i = 0; i < ARRAY_SIZE(CTheScripts::IntroTextLines); i++) {
+		intro_text_line &line = CTheScripts::IntroTextLines[i];
+		if (line.m_Text[0] != '\0' && !line.m_bTextBeforeFade) {
+
+			CFont::SetScale(SCREEN_SCALE_X_PC(line.m_fScaleX), SCREEN_SCALE_Y_PC(line.m_fScaleY)
+#if !defined(PS2_HUD) || defined(FIX_BUGS)
+				/ 2
+#endif
+				);
+			CFont::SetColor(line.m_sColor);
+			if (line.m_bJustify)
+				CFont::SetJustifyOn();
+			else
+				CFont::SetJustifyOff();
+
+			if (line.m_bRightJustify)
+				CFont::SetRightJustifyOn();
+			else
+				CFont::SetRightJustifyOff();
+
+			if (line.m_bCentered)
+				CFont::SetCentreOn();
+			else
+				CFont::SetCentreOff();
+
+			CFont::SetWrapx(SCALE_AND_CENTER_X_PC(line.m_fWrapX));
+			CFont::SetCentreSize(SCREEN_SCALE_X_PC(line.m_fCenterSize));
+			
+			if (line.m_bBackground)
+				CFont::SetBackgroundOn();
+			else
+				CFont::SetBackgroundOff();
+
+			CFont::SetBackgroundColor(line.m_sBackgroundColor);
+			if (line.m_bBackgroundOnly)
+				CFont::SetBackGroundOnlyTextOn();
+			else
+				CFont::SetBackGroundOnlyTextOff();
+
+			if (line.m_bTextProportional)
+				CFont::SetPropOn();
+			else
+				CFont::SetPropOff();
+
+			CFont::SetFontStyle(line.m_nFont);
+#if defined(PS2_HUD) && !defined(FIX_BUGS)
+			CFont::PrintString(line.m_fAtX, line.m_fAtY, line.m_Text);
+#else
+			CFont::PrintString(SCALE_AND_CENTER_X(DEFAULT_SCREEN_WIDTH - line.m_fAtX), SCREEN_SCALE_Y(DEFAULT_SCREEN_HEIGHT - line.m_fAtY), line.m_Text);
+#endif
+		}
+	}
+	for (int i = 0; i < ARRAY_SIZE(CTheScripts::IntroRectangles); i++) {
+		intro_script_rectangle &rectangle = CTheScripts::IntroRectangles[i];
+		if (rectangle.m_bIsUsed && !rectangle.m_bBeforeFade) {
+
+			// Yeah, top and bottom changed place. R* vision
+			if (rectangle.m_nTextureId >= 0) {
+				CTheScripts::ScriptSprites[rectangle.m_nTextureId].Draw(CRect(rectangle.m_sRect.left, rectangle.m_sRect.bottom,
+					rectangle.m_sRect.right, rectangle.m_sRect.top), rectangle.m_sColor);
+			} else {
+				CSprite2d::DrawRect(CRect(rectangle.m_sRect.left, rectangle.m_sRect.bottom,
+					rectangle.m_sRect.right, rectangle.m_sRect.top), rectangle.m_sColor);
+			}
+		}
+	}
+
+	/*
+		DrawBigMessage2
+	*/
+	// Oddjob
+	if (m_BigMessage[3][0]) {
+		CFont::SetJustifyOff();
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X_PC(1.2f), SCREEN_SCALE_Y_PC(1.5f));
+		CFont::SetCentreOn();
+		CFont::SetPropOn();
+		CFont::SetCentreSize(SCREEN_SCALE_X(DEFAULT_SCREEN_WIDTH - 40));
+		CFont::SetFontStyle(FONT_LOCALE(FONT_BANK));
+		CFont::SetColor(CRGBA(0, 0, 0, 255));
+		CFont::PrintString((SCREEN_WIDTH / 2) + SCREEN_SCALE_X_FIX(2.0f), (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(BIGMESSAGE_Y) + SCREEN_SCALE_Y_FIX(2.0f), m_BigMessage[3]);
+		CFont::SetColor(ODDJOB_COLOR);
+		CFont::PrintString((SCREEN_WIDTH / 2), (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(BIGMESSAGE_Y), m_BigMessage[3]);
+	}
+
+	if (!m_BigMessage[1][0] && m_BigMessage[4][0]) {
+		CFont::SetJustifyOff();
+		CFont::SetBackgroundOff();
+		CFont::SetScale(SCREEN_SCALE_X_PC(1.2f), SCREEN_SCALE_Y_PC(1.5f));
+		CFont::SetCentreOn();
+		CFont::SetPropOn();
+		CFont::SetCentreSize(SCREEN_SCALE_X(DEFAULT_SCREEN_WIDTH - 20));
+		CFont::SetColor(CRGBA(0, 0, 0, 255));
+		CFont::SetFontStyle(FONT_LOCALE(FONT_BANK));
+		CFont::PrintString((SCREEN_WIDTH / 2) - SCREEN_SCALE_X_FIX(2.0f), (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(BIGMESSAGE_Y) - SCREEN_SCALE_Y_FIX(2.0f), m_BigMessage[4]);
+		CFont::SetColor(ODDJOB_COLOR);
+		CFont::PrintString((SCREEN_WIDTH / 2), (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(BIGMESSAGE_Y), m_BigMessage[4]);
+	}
+
+	// Oddjob result
+	if (OddJob2OffTimer > 0)
+		OddJob2OffTimer -= CTimer::GetTimeStepInMilliseconds();
+
+	float fStep;
+	if (m_BigMessage[5][0] && OddJob2OffTimer <= 0.0f) {
+		switch (OddJob2On) {
+			case 0:
+				OddJob2On = 1;
+				OddJob2XOffset = 380.0f;
+				break;
+			case 1:
+				if (OddJob2XOffset <= 2.0f) {
+					OddJob2Timer = 0;
+					OddJob2On = 2;
+				}
+				else {
+					fStep = Min(40.0f, OddJob2XOffset / 6.0f);
+					OddJob2XOffset = OddJob2XOffset - fStep;
+				}
+				break;
+			case 2:
+				OddJob2Timer += CTimer::GetTimeStepInMilliseconds();
+				if (OddJob2Timer > 1500) {
+					OddJob2On = 3;
+				}
+				break;
+			case 3:
+				fStep = Max(30.0f, OddJob2XOffset / 5.0f);
+
+				OddJob2XOffset = OddJob2XOffset - fStep;
+
+				if (OddJob2XOffset < -380.0f) {
+					OddJob2OffTimer = 5000.0f;
+					OddJob2On = 0;
+				}
+				break;
+			default:
+				break;
+		}
+
+		if (!m_BigMessage[1][0]) {
+			CFont::SetJustifyOff();
+			CFont::SetBackgroundOff();
+			CFont::SetScale(SCREEN_SCALE_X(1.0f), SCREEN_SCALE_Y(1.2f));
+			CFont::SetCentreOn();
+			CFont::SetPropOn();
+			// Not bug, we just want these kind of texts to be wrapped at the center.
+#ifdef ASPECT_RATIO_SCALE
+			CFont::SetCentreSize(SCREEN_SCALE_X(DEFAULT_SCREEN_WIDTH - 20.0f));
+#else
+			CFont::SetCentreSize(SCREEN_SCALE_FROM_RIGHT(20.0f));
+#endif
+			CFont::SetColor(CRGBA(0, 0, 0, 255));
+			CFont::SetFontStyle(FONT_LOCALE(FONT_BANK));
+
+#ifdef BETA_SLIDING_TEXT
+			CFont::PrintString(SCREEN_WIDTH / 2 + SCREEN_SCALE_X_PC(2.0f) - SCREEN_SCALE_X(OddJob2XOffset), SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(20.0f) + SCREEN_SCALE_Y_PC(2.0f), m_BigMessage[5]);
+			CFont::SetColor(ODDJOB2_COLOR);
+			CFont::PrintString(SCREEN_WIDTH / 2 - SCREEN_SCALE_X(OddJob2XOffset), SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(20.0f), m_BigMessage[5]);
+#else
+			CFont::PrintString(SCREEN_WIDTH / 2 + SCREEN_SCALE_X_PC(2.0f), SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(20.0f) + SCREEN_SCALE_Y_PC(2.0f), m_BigMessage[5]);
+			CFont::SetColor(ODDJOB2_COLOR);
+			CFont::PrintString(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(20.0f), m_BigMessage[5]);
+#endif
+		}
+	}
+
+	/*
+		DrawMissionTitle
+	*/
+	if (m_BigMessage[1][0]) {
+		if (BigMessageInUse[1] != 0.0f) {
+			CFont::SetJustifyOff();
+			CFont::SetBackgroundOff();
+
+			if (CGame::frenchGame || FrontEndMenuManager.m_PrefsLanguage == CMenuManager::LANGUAGE_SPANISH)
+				CFont::SetScale(SCREEN_SCALE_X_PC(0.884f), SCREEN_SCALE_Y_PC(1.36f));
+			else
+				CFont::SetScale(SCREEN_SCALE_X_PC(1.04f), SCREEN_SCALE_Y_PC(1.6f));
+
+			CFont::SetPropOn();
+#ifdef FIX_BUGS
+			CFont::SetRightJustifyWrap(SCREEN_SCALE_FROM_RIGHT(DEFAULT_SCREEN_WIDTH + 500.0f));
+#else
+			CFont::SetRightJustifyWrap(-500.0f);
+#endif
+			CFont::SetRightJustifyOn();
+			CFont::SetFontStyle(FONT_HEADING);
+			
+			if (BigMessageX[1] >= SCREEN_WIDTH - SCREEN_SCALE_X_FIX(20.0f))
+			{
+				BigMessageInUse[1] += CTimer::GetTimeStep();
+
+				if (BigMessageInUse[1] >= 120.0f) {
+					BigMessageInUse[1] = 120.0f;
+					BigMessageAlpha[1] -= (CTimer::GetTimeStepInMilliseconds() * 0.3f);
+				}
+				if (BigMessageAlpha[1] <= 0) {
+					m_BigMessage[1][0] = 0;
+					BigMessageAlpha[1] = 0.0f;
+				}
+			} else {
+				BigMessageX[1] += SCREEN_SCALE_X_FIX(CTimer::GetTimeStepInMilliseconds() * 0.3f);
+				BigMessageAlpha[1] += (CTimer::GetTimeStepInMilliseconds() * 0.3f);
+
+				if (BigMessageAlpha[1] > 255.0f)
+					BigMessageAlpha[1] = 255.0f;
+			}
+
+			CFont::SetColor(CRGBA(40, 40, 40, BigMessageAlpha[1]));
+#ifdef BETA_SLIDING_TEXT
+			CFont::PrintString(SCREEN_SCALE_X(2.0f) + BigMessageX[1], SCREEN_SCALE_FROM_BOTTOM(120.0f) + SCREEN_SCALE_Y_PC(2.0f), m_BigMessage[1]);
+			CFont::SetColor(CRGBA(MISSIONTITLE_COLOR.r, MISSIONTITLE_COLOR.g, MISSIONTITLE_COLOR.b, BigMessageAlpha[1]));
+			CFont::PrintString(BigMessageX[1], SCREEN_SCALE_FROM_BOTTOM(120.0f), m_BigMessage[1]);
+#else
+			CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(20.0f) + SCREEN_SCALE_X_FIX(2.0f), SCREEN_SCALE_FROM_BOTTOM(120.0f) + SCREEN_SCALE_Y_PC(2.0f), m_BigMessage[1]);
+			CFont::SetColor(CRGBA(MISSIONTITLE_COLOR.r, MISSIONTITLE_COLOR.g, MISSIONTITLE_COLOR.b, BigMessageAlpha[1]));
+			CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(20.0f), SCREEN_SCALE_FROM_BOTTOM(120.0f), m_BigMessage[1]);
+#endif
+		}
+		else {
+			BigMessageAlpha[1] = 0.0f;
+#ifdef FIX_BUGS
+			BigMessageX[1] = SCREEN_SCALE_FROM_RIGHT(DEFAULT_SCREEN_WIDTH + 60.0f);
+#else
+			BigMessageX[1] = -60.0f;
+#endif
+			BigMessageInUse[1] = 1.0f;
+		}
+	}
+	else {
+		BigMessageInUse[1] = 0.0f;
+	}
+}
+
+void CHud::SetMessage(wchar *message)
+{
+	int i = 0;
+	for (i = 0; i < ARRAY_SIZE(m_Message); i++) {
+		if (message[i] == 0)
+			break;
+
+		m_Message[i] = message[i];
+	}
+	m_Message[i] = 0;
+}
+
+void CHud::SetBigMessage(wchar *message, uint16 style)
+{
+	int i = 0;
+
+	if (style == 5) {
+		for (i = 0; i < 128; i++) {
+			if (message[i] == 0)
+				break;
+
+			if (message[i] != LastBigMessage[5][i]) {
+				OddJob2On = 0;
+				OddJob2OffTimer = 0.0f;
+			}
+
+			m_BigMessage[5][i] = message[i];
+			LastBigMessage[5][i] = message[i];
+		}
+	} else {
+		for (i = 0; i < 128; i++) {
+			if (message[i] == 0)
+				break;
+			m_BigMessage[style][i] = message[i];
+		}
+	}
+	LastBigMessage[style][i] = 0;
+	m_BigMessage[style][i] = 0;
+#ifndef FIX_BUGS
+	m_BigMessage[style][i] = 0;
+#endif
+}
+
+void CHud::SetPagerMessage(wchar *message)
+{
+	int i = 0;
+	for (i = 0; i < ARRAY_SIZE(m_PagerMessage); i++) {
+		if (message[i] == 0)
+			break;
+
+		m_PagerMessage[i] = message[i];
+	}
+	m_PagerMessage[i] = 0;
+}
\ No newline at end of file
diff --git a/src/renderer/Hud.h b/src/renderer/Hud.h
new file mode 100644
index 00000000..adfdf1fc
--- /dev/null
+++ b/src/renderer/Hud.h
@@ -0,0 +1,81 @@
+#pragma once
+#include "Sprite2d.h"
+
+#define HELP_MSG_LENGTH 256
+
+enum eItems
+{
+	ITEM_NONE = -1,
+	ITEM_ARMOUR = 3,
+	ITEM_HEALTH = 4,
+	ITEM_RADAR = 8
+};
+
+enum eSprites 
+{
+	HUD_FIST,
+	HUD_BAT,
+	HUD_PISTOL,
+	HUD_UZI,
+	HUD_SHOTGUN,
+	HUD_AK47,
+	HUD_M16,
+	HUD_SNIPER,
+	HUD_ROCKET,
+	HUD_FLAME,
+	HUD_MOLOTOV,
+	HUD_GRENADE,
+	HUD_DETONATOR,
+	HUD_RADARDISC = 15,
+	HUD_PAGER = 16,
+	HUD_SITESNIPER = 20,
+	HUD_SITEM16,
+	HUD_SITEROCKET,
+	NUM_HUD_SPRITES,
+};
+
+class CHud
+{
+public:
+	static int16 m_ItemToFlash;
+	static CSprite2d Sprites[NUM_HUD_SPRITES];
+	static wchar *m_pZoneName;
+	static wchar *m_pLastZoneName;
+	static wchar *m_ZoneToPrint;
+	static wchar m_Message[256];
+	static wchar m_BigMessage[6][128];
+	static wchar m_PagerMessage[256];
+	static uint32 m_ZoneNameTimer;
+	static int32 m_ZoneFadeTimer;
+	static uint32 m_ZoneState;
+	static wchar m_HelpMessage[HELP_MSG_LENGTH];
+	static wchar m_LastHelpMessage[HELP_MSG_LENGTH];
+	static wchar m_HelpMessageToPrint[HELP_MSG_LENGTH];
+	static uint32 m_HelpMessageTimer;
+	static int32 m_HelpMessageFadeTimer;
+	static uint32 m_HelpMessageState;
+	static bool	m_HelpMessageQuick;
+	static float m_HelpMessageDisplayTime;
+	static int32 SpriteBrightness;
+	static bool m_Wants_To_Draw_Hud;
+	static bool m_Wants_To_Draw_3dMarkers;
+	static wchar *m_pVehicleName;
+	static wchar *m_pLastVehicleName;
+	static uint32 m_VehicleNameTimer;
+	static int32 m_VehicleFadeTimer;
+	static uint32 m_VehicleState;
+	static wchar *m_pVehicleNameToPrint;
+public:
+	static void Initialise();
+	static void Shutdown();
+	static void ReInitialise();
+	static void GetRidOfAllHudMessages();
+	static void SetZoneName(wchar *name);
+	static void SetHelpMessage(wchar *message, bool quick);
+	static void SetVehicleName(wchar *name);
+	static void Draw();
+	static void DrawAfterFade();
+	static void SetMessage(wchar *message);
+	static void SetBigMessage(wchar *message, uint16 style);
+	static void SetPagerMessage(wchar *message);
+};
diff --git a/src/renderer/Instance.cpp b/src/renderer/Instance.cpp
new file mode 100644
index 00000000..be6d73d6
--- /dev/null
+++ b/src/renderer/Instance.cpp
@@ -0,0 +1,9 @@
+#include "common.h"
+
+#include "Instance.h"
+
+void
+CInstance::Shutdown()
+{
+	GetMatrix().Detach();
+}
diff --git a/src/renderer/Instance.h b/src/renderer/Instance.h
new file mode 100644
index 00000000..693cfdf1
--- /dev/null
+++ b/src/renderer/Instance.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Placeable.h"
+
+// unused
+
+class CInstance : public CPlaceable
+{
+public:
+	int m_modelIndex;
+public:
+	~CInstance() { }
+	void Shutdown();
+};
diff --git a/src/renderer/Lines.cpp b/src/renderer/Lines.cpp
new file mode 100644
index 00000000..b5c85149
--- /dev/null
+++ b/src/renderer/Lines.cpp
@@ -0,0 +1,74 @@
+#include "common.h"
+
+#include "main.h"
+#include "Lines.h"
+
+// This is super inefficient, why split the line into segments at all?
+void
+CLines::RenderLineWithClipping(float x1, float y1, float z1, float x2, float y2, float z2, uint32 c1, uint32 c2)
+{
+	static RwIm3DVertex v[2];
+#ifdef THIS_IS_STUPID
+	int i;
+	float f1, f2;
+	float len = sqrt(sq(x1-x2) + sq(y1-y2) + sq(z1-z2));
+	int numsegs = len/1.5f + 1.0f;
+
+	RwRGBA col1;
+	col1.red = c1>>24;
+	col1.green = c1>>16;
+	col1.blue = c1>>8;
+	col1.alpha = c1;
+	RwRGBA col2;
+	col2.red = c2>>24;
+	col2.green = c2>>16;
+	col2.blue = c2>>8;
+	col2.alpha = c2;
+
+	float dx = x2 - x1;
+	float dy = y2 - y1;
+	float dz = z2 - z1;
+	for(i = 0; i < numsegs; i++){
+		f1 = (float)i/numsegs;
+		f2 = (float)(i+1)/numsegs;
+
+		RwIm3DVertexSetRGBA(&v[0], (int)(col1.red + (col2.red-col1.red)*f1),
+			(int)(col1.green + (col2.green-col1.green)*f1),
+			(int)(col1.blue + (col2.blue-col1.blue)*f1),
+			(int)(col1.alpha + (col2.alpha-col1.alpha)*f1));
+		RwIm3DVertexSetRGBA(&v[1], (int)(col1.red + (col2.red-col1.red)*f2),
+			(int)(col1.green + (col2.green-col1.green)*f2),
+			(int)(col1.blue + (col2.blue-col1.blue)*f2),
+			(int)(col1.alpha + (col2.alpha-col1.alpha)*f2));
+		RwIm3DVertexSetPos(&v[0], x1 + dx*f1, y1 + dy*f1, z1 + dz*f1);
+		RwIm3DVertexSetPos(&v[1], x1 + dx*f2, y1 + dy*f2, z1 + dz*f2);
+
+		LittleTest();
+		if(RwIm3DTransform(v, 2, nil, 0)){
+			RwIm3DRenderLine(0, 1);
+			RwIm3DEnd();
+		}
+	}
+#else
+	RwRGBA col1;
+	col1.red = c1>>24;
+	col1.green = c1>>16;
+	col1.blue = c1>>8;
+	col1.alpha = c1;
+	RwRGBA col2;
+	col2.red = c2>>24;
+	col2.green = c2>>16;
+	col2.blue = c2>>8;
+	col2.alpha = c2;
+
+	RwIm3DVertexSetRGBA(&v[0], col1.red, col1.green, col1.blue, col1.alpha);
+	RwIm3DVertexSetRGBA(&v[1], col2.red, col2.green, col2.blue, col2.alpha);
+	RwIm3DVertexSetPos(&v[0], x1, y1, z1);
+	RwIm3DVertexSetPos(&v[1], x2, y2, z2);
+	LittleTest();
+	if(RwIm3DTransform(v, 2, nil, 0)){
+		RwIm3DRenderLine(0, 1);
+		RwIm3DEnd();
+	}
+#endif
+}
diff --git a/src/renderer/Lines.h b/src/renderer/Lines.h
new file mode 100644
index 00000000..f2694fc0
--- /dev/null
+++ b/src/renderer/Lines.h
@@ -0,0 +1,7 @@
+#pragma once
+
+class CLines
+{
+public:
+	static void RenderLineWithClipping(float x1, float y1, float z1, float x2, float y2, float z2, uint32 c1, uint32 c2);
+};
diff --git a/src/renderer/MBlur.cpp b/src/renderer/MBlur.cpp
new file mode 100644
index 00000000..8e5fba2a
--- /dev/null
+++ b/src/renderer/MBlur.cpp
@@ -0,0 +1,325 @@
+#ifndef LIBRW
+#define WITHD3D
+#endif
+#include "common.h"
+#ifndef LIBRW
+#include <d3d8caps.h>
+#endif
+
+#include "main.h"
+#include "RwHelper.h"
+#include "Camera.h"
+#include "MBlur.h"
+#include "postfx.h"
+
+// Originally taken from RW example 'mblur'
+
+RwRaster *CMBlur::pFrontBuffer;
+bool CMBlur::ms_bJustInitialised;
+bool CMBlur::ms_bScaledBlur;
+bool CMBlur::BlurOn;
+
+static RwIm2DVertex Vertex[4];
+static RwImVertexIndex Index[6] = { 0, 1, 2, 0, 2, 3 };
+
+#ifndef LIBRW
+extern "C" D3DCAPS8 _RwD3D8DeviceCaps;
+#endif
+RwBool
+CMBlur::MotionBlurOpen(RwCamera *cam)
+{
+#ifdef EXTENDED_COLOURFILTER
+	CPostFX::Open(cam);
+	return TRUE;
+#else
+#ifdef GTA_PS2
+	RwRect rect = {0, 0, 0, 0};
+	
+	if (pFrontBuffer)
+		return TRUE;
+	
+	BlurOn = true;
+	
+	rect.w = RwRasterGetWidth(RwCameraGetRaster(cam));
+	rect.h = RwRasterGetHeight(RwCameraGetRaster(cam));
+	
+	pFrontBuffer = RwRasterCreate(0, 0, 0, rwRASTERDONTALLOCATE|rwRASTERTYPECAMERATEXTURE);
+	if (!pFrontBuffer)
+	{
+		printf("Error creating raster\n");
+		return FALSE;
+	}
+	
+	RwRaster *raster = RwRasterSubRaster(pFrontBuffer, RwCameraGetRaster(cam), &rect);
+	if (!raster)
+	{
+		RwRasterDestroy(pFrontBuffer);
+		pFrontBuffer = NULL;
+		printf("Error subrastering\n");
+		return FALSE;
+	}
+	
+	CreateImmediateModeData(cam, &rect);
+#else
+	RwRect rect = { 0, 0, 0, 0 };
+
+	if(pFrontBuffer)
+		MotionBlurClose();
+	
+#ifndef LIBRW
+	extern void _GetVideoMemInfo(LPDWORD total, LPDWORD avaible);
+	DWORD total, avaible;
+	
+	_GetVideoMemInfo(&total, &avaible);
+	debug("Available video memory %d\n", avaible);
+#endif
+		
+	if(BlurOn)
+	{
+		uint32 width  = Pow(2.0f, int32(log2(RwRasterGetWidth (RwCameraGetRaster(cam))))+1);
+		uint32 height = Pow(2.0f, int32(log2(RwRasterGetHeight(RwCameraGetRaster(cam))))+1);
+		uint32 depth  = RwRasterGetDepth(RwCameraGetRaster(cam));
+		
+#ifndef LIBRW
+		extern DWORD _dwMemTotalVideo;
+		if ( _RwD3D8DeviceCaps.MaxTextureWidth >= width && _RwD3D8DeviceCaps.MaxTextureHeight >= height )
+		{
+			total = _dwMemTotalVideo - 3 *
+				( RwRasterGetDepth(RwCameraGetRaster(cam))
+				* RwRasterGetHeight(RwCameraGetRaster(cam))
+				* RwRasterGetWidth(RwCameraGetRaster(cam)) / 8 );
+			BlurOn = total >= height*width*(depth/8) + (12*1024*1024) /*12 MB*/;
+		}
+		else
+			BlurOn = false;
+#endif
+		
+		if ( BlurOn )
+		{
+			ms_bScaledBlur = false;
+			rect.w = width;
+			rect.h = height;
+			
+			pFrontBuffer = RwRasterCreate(rect.w, rect.h, depth, rwRASTERTYPECAMERATEXTURE);
+			if ( !pFrontBuffer )
+			{
+				debug("MBlurOpen can't create raster.");
+				BlurOn = false;
+				rect.w = RwRasterGetWidth(RwCameraGetRaster(cam));
+				rect.h = RwRasterGetHeight(RwCameraGetRaster(cam));
+			}
+			else
+				ms_bJustInitialised = true;
+		}
+		else
+		{
+			rect.w = RwRasterGetWidth(RwCameraGetRaster(cam));
+			rect.h = RwRasterGetHeight(RwCameraGetRaster(cam));
+		}
+		
+#ifndef LIBRW
+		_GetVideoMemInfo(&total, &avaible);
+		debug("Available video memory %d\n", avaible);
+#endif
+		CreateImmediateModeData(cam, &rect);
+	}
+	else
+	{
+		rect.w = RwRasterGetWidth(RwCameraGetRaster(cam));
+		rect.h = RwRasterGetHeight(RwCameraGetRaster(cam));
+		CreateImmediateModeData(cam, &rect);
+	}
+	
+	return TRUE;
+#endif
+#endif
+}
+
+RwBool
+CMBlur::MotionBlurClose(void)
+{
+#ifdef EXTENDED_COLOURFILTER
+	CPostFX::Close();
+#else
+	if(pFrontBuffer){
+		RwRasterDestroy(pFrontBuffer);
+		pFrontBuffer = nil;
+		
+		return TRUE;
+	}
+#endif
+	return FALSE;
+}
+
+void
+CMBlur::CreateImmediateModeData(RwCamera *cam, RwRect *rect)
+{
+	float zero, xmax, ymax;
+
+	if(RwRasterGetDepth(RwCameraGetRaster(cam)) == 16){
+		zero = HALFPX;
+		xmax = rect->w + HALFPX;
+		ymax = rect->h + HALFPX;
+	}else{
+		zero = -HALFPX;
+		xmax = rect->w - HALFPX;
+		ymax = rect->h - HALFPX;
+	}
+
+	RwIm2DVertexSetScreenX(&Vertex[0], zero);
+	RwIm2DVertexSetScreenY(&Vertex[0], zero);
+	RwIm2DVertexSetScreenZ(&Vertex[0], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex[0], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex[0], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex[0], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex[0], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex[0], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex[1], zero);
+	RwIm2DVertexSetScreenY(&Vertex[1], ymax);
+	RwIm2DVertexSetScreenZ(&Vertex[1], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex[1], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex[1], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex[1], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex[1], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex[1], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex[2], xmax);
+	RwIm2DVertexSetScreenY(&Vertex[2], ymax);
+	RwIm2DVertexSetScreenZ(&Vertex[2], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex[2], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex[2], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex[2], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex[2], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex[2], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex[3], xmax);
+	RwIm2DVertexSetScreenY(&Vertex[3], zero);
+	RwIm2DVertexSetScreenZ(&Vertex[3], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex[3], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex[3], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex[3], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex[3], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex[3], 255, 255, 255, 255);
+}
+
+void
+CMBlur::MotionBlurRender(RwCamera *cam, uint32 red, uint32 green, uint32 blue, uint32 blur, int32 type, uint32 bluralpha)
+{
+#ifdef EXTENDED_COLOURFILTER
+	CPostFX::Render(cam, red, green, blue, blur, type, bluralpha);
+#else
+	PUSH_RENDERGROUP("CMBlur::MotionBlurRender");
+	RwRGBA color = { (RwUInt8)red, (RwUInt8)green, (RwUInt8)blue, (RwUInt8)blur };
+#ifdef GTA_PS2
+	if( pFrontBuffer )
+		OverlayRender(cam, pFrontBuffer, color, type, bluralpha);
+#else
+	if(BlurOn){
+		if(pFrontBuffer){
+			if(ms_bJustInitialised)
+				ms_bJustInitialised = false;
+			else
+				OverlayRender(cam, pFrontBuffer, color, type, bluralpha);
+		}
+		RwRasterPushContext(pFrontBuffer);
+		RwRasterRenderFast(RwCameraGetRaster(cam), 0, 0);
+		RwRasterPopContext();
+	}else{
+		OverlayRender(cam, nil, color, type, bluralpha);
+	}
+#endif
+	POP_RENDERGROUP();
+#endif
+}
+
+void
+CMBlur::OverlayRender(RwCamera *cam, RwRaster *raster, RwRGBA color, int32 type, int32 bluralpha)
+{
+	int r, g, b, a;
+
+	r = color.red;
+	g = color.green;
+	b = color.blue;
+	a = color.alpha;
+
+	DefinedState();
+
+	switch(type)
+	{
+	case MOTION_BLUR_SECURITY_CAM:
+		r = 0;
+		g = 255;
+		b = 0;
+		a = 128;
+		break;
+	case MOTION_BLUR_INTRO:
+		r = 100;
+		g = 220;
+		b = 230;
+		a = 158;
+		break;
+	case MOTION_BLUR_INTRO2:
+		r = 80;
+		g = 255;
+		b = 230;
+		a = 138;
+		break;
+	case MOTION_BLUR_INTRO3:
+		r = 255;
+		g = 60;
+		b = 60;
+		a = 200;
+		break;
+	case MOTION_BLUR_INTRO4:
+		r = 255;
+		g = 180;
+		b = 180;
+		a = 128;
+		break;
+	}
+
+	if(!BlurOn){
+		r = Min(r*0.6f, 255.0f);
+		g = Min(g*0.6f, 255.0f);
+		b = Min(b*0.6f, 255.0f);
+		if(type != MOTION_BLUR_SNIPER)
+			a = Min(a*0.6f, 255.0f);
+		// game clamps to 255 here, but why?
+	}
+	RwIm2DVertexSetIntRGBA(&Vertex[0], r, g, b, a);
+	RwIm2DVertexSetIntRGBA(&Vertex[1], r, g, b, a);
+	RwIm2DVertexSetIntRGBA(&Vertex[2], r, g, b, a);
+	RwIm2DVertexSetIntRGBA(&Vertex[3], r, g, b, a);
+
+	RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void*)rwFILTERNEAREST);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, BlurOn ? raster : nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+
+	a = bluralpha/2;
+	if(a < 30)
+		a = 30;
+
+	if(BlurOn && a != 0){	// the second condition should always be true
+		RwIm2DVertexSetIntRGBA(&Vertex[0], 255, 255, 255, a);
+		RwIm2DVertexSetIntRGBA(&Vertex[1], 255, 255, 255, a);
+		RwIm2DVertexSetIntRGBA(&Vertex[2], 255, 255, 255, a);
+		RwIm2DVertexSetIntRGBA(&Vertex[3], 255, 255, 255, a);
+		RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+	}
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+}
diff --git a/src/renderer/MBlur.h b/src/renderer/MBlur.h
new file mode 100644
index 00000000..e2e5d38c
--- /dev/null
+++ b/src/renderer/MBlur.h
@@ -0,0 +1,17 @@
+#pragma once
+
+class CMBlur
+{
+public:
+	static RwRaster *pFrontBuffer;
+	static bool ms_bJustInitialised;
+	static bool ms_bScaledBlur;
+	static bool BlurOn;
+
+public:
+	static RwBool MotionBlurOpen(RwCamera *cam);
+	static RwBool MotionBlurClose(void);
+	static void CreateImmediateModeData(RwCamera *cam, RwRect *rect);
+	static void MotionBlurRender(RwCamera *cam, uint32 red, uint32 green, uint32 blue, uint32 blur, int32 type, uint32 bluralpha);
+	static void OverlayRender(RwCamera *cam, RwRaster *raster, RwRGBA color, int32 type, int32 bluralpha);
+};
diff --git a/src/renderer/Particle.cpp b/src/renderer/Particle.cpp
new file mode 100644
index 00000000..76ddde50
--- /dev/null
+++ b/src/renderer/Particle.cpp
@@ -0,0 +1,1902 @@
+#include "common.h"
+
+#include "main.h"
+#include "General.h"
+#include "Timer.h"
+#include "TxdStore.h"
+#include "Entity.h"
+#include "Sprite.h"
+#include "Camera.h"
+#include "Collision.h"
+#include "World.h"
+#include "Shadows.h"
+#include "AudioScriptObject.h"
+#include "ParticleObject.h"
+#include "Particle.h"
+#include "soundlist.h"
+#include "debugmenu.h"
+
+
+#define MAX_PARTICLES_ON_SCREEN   (1000)
+
+
+//(5)
+#define MAX_SMOKE_FILES           ARRAY_SIZE(SmokeFiles)
+
+//(5)
+#define MAX_SMOKE2_FILES          ARRAY_SIZE(Smoke2Files)
+//(5) 
+#define MAX_RUBBER_FILES          ARRAY_SIZE(RubberFiles)
+//(5)
+#define MAX_RAINSPLASH_FILES      ARRAY_SIZE(RainSplashFiles)
+//(3)
+#define MAX_WATERSPRAY_FILES      ARRAY_SIZE(WatersprayFiles)
+//(6)
+#define MAX_EXPLOSIONMEDIUM_FILES ARRAY_SIZE(ExplosionMediumFiles)
+//(4)
+#define MAX_GUNFLASH_FILES        ARRAY_SIZE(GunFlashFiles)
+//(2)
+#define MAX_RAINSPLASHUP_FILES    ARRAY_SIZE(RainSplashupFiles)
+//(4)
+#define MAX_BIRDFRONT_FILES       ARRAY_SIZE(BirdfrontFiles)
+//(4)
+#define MAX_CARDEBRIS_FILES       ARRAY_SIZE(CardebrisFiles)
+//(4)
+#define MAX_CARSPLASH_FILES       ARRAY_SIZE(CarsplashFiles)
+
+//(4)
+#define MAX_RAINDROP_FILES        ARRAY_SIZE(RaindropFiles)
+
+
+
+const char SmokeFiles[][6+1] =
+{
+	"smoke1",
+	"smoke2",
+	"smoke3",
+	"smoke4",
+	"smoke5"
+};
+
+
+const char Smoke2Files[][9+1] =
+{
+	"smokeII_1",
+	"smokeII_2",
+	"smokeII_3",
+	"smokeII_4",
+	"smokeII_5"
+};
+
+const char RubberFiles[][7+1] =
+{
+	"rubber1",
+	"rubber2",
+	"rubber3",
+	"rubber4",
+	"rubber5"
+};
+
+const char RainSplashFiles[][7+1] =
+{
+	"splash1",
+	"splash2",
+	"splash3",
+	"splash4",
+	"splash5"
+};
+
+const char WatersprayFiles[][11+1] =
+{
+	"waterspray1",
+	"waterspray2",
+	"waterspray3"
+};
+
+const char ExplosionMediumFiles[][7+1] =
+{
+	"explo01",
+	"explo02",
+	"explo03",
+	"explo04",
+	"explo05",
+	"explo06"
+};
+
+const char GunFlashFiles[][9+1] =
+{
+	"gunflash1",
+	"gunflash2",
+	"gunflash3",
+	"gunflash4"
+};
+
+const char RaindropFiles[][9+1] =
+{
+	"raindrop1",
+	"raindrop2",
+	"raindrop3",
+	"raindrop4"
+};
+
+const char RainSplashupFiles[][10+1] =
+{
+	"splash_up1",
+	"splash_up2"
+};
+
+const char BirdfrontFiles[][8+1] =
+{
+	"birdf_01",
+	"birdf_02",
+	"birdf_03",
+	"birdf_04"
+};
+
+const char CardebrisFiles[][12+1] =
+{
+	"cardebris_01",
+	"cardebris_02",
+	"cardebris_03",
+	"cardebris_04"
+};
+				
+const char CarsplashFiles[][12+1] =
+{
+	"carsplash_01",
+	"carsplash_02",
+	"carsplash_03",
+	"carsplash_04"
+};
+
+CParticle gParticleArray[MAX_PARTICLES_ON_SCREEN];
+
+RwTexture *gpSmokeTex[MAX_SMOKE_FILES];
+RwTexture *gpSmoke2Tex[MAX_SMOKE2_FILES];
+RwTexture *gpRubberTex[MAX_RUBBER_FILES];
+RwTexture *gpRainSplashTex[MAX_RAINSPLASH_FILES];
+RwTexture *gpWatersprayTex[MAX_WATERSPRAY_FILES];
+RwTexture *gpExplosionMediumTex[MAX_EXPLOSIONMEDIUM_FILES];
+RwTexture *gpGunFlashTex[MAX_GUNFLASH_FILES];
+RwTexture *gpRainSplashupTex[MAX_RAINSPLASHUP_FILES];
+RwTexture *gpBirdfrontTex[MAX_BIRDFRONT_FILES];
+RwTexture *gpCarDebrisTex[MAX_CARDEBRIS_FILES];
+RwTexture *gpCarSplashTex[MAX_CARSPLASH_FILES];
+
+RwTexture *gpFlame1Tex;
+RwTexture *gpFlame5Tex;
+RwTexture *gpRainDropSmallTex;
+RwTexture *gpBloodTex;
+RwTexture *gpLeafTex;
+RwTexture *gpCloudTex1; // unused
+RwTexture *gpCloudTex4;
+RwTexture *gpBloodSmallTex;
+RwTexture *gpGungeTex;
+RwTexture *gpCollisionSmokeTex;
+RwTexture *gpBulletHitTex;
+RwTexture *gpGunShellTex;
+RwTexture *gpWakeOldTex;
+RwTexture *gpPointlightTex;
+
+RwRaster  *gpSmokeRaster[MAX_SMOKE_FILES];
+RwRaster  *gpSmoke2Raster[MAX_SMOKE2_FILES];
+RwRaster  *gpRubberRaster[MAX_RUBBER_FILES];
+RwRaster  *gpRainSplashRaster[MAX_RAINSPLASH_FILES];
+RwRaster  *gpWatersprayRaster[MAX_WATERSPRAY_FILES];
+RwRaster  *gpExplosionMediumRaster[MAX_EXPLOSIONMEDIUM_FILES];
+RwRaster  *gpGunFlashRaster[MAX_GUNFLASH_FILES];
+RwRaster  *gpRainSplashupRaster[MAX_RAINSPLASHUP_FILES];
+RwRaster  *gpBirdfrontRaster[MAX_BIRDFRONT_FILES];
+RwRaster  *gpCarDebrisRaster[MAX_CARDEBRIS_FILES];
+RwRaster  *gpCarSplashRaster[MAX_CARSPLASH_FILES];
+
+RwRaster  *gpFlame1Raster;
+RwRaster  *gpFlame5Raster;
+RwRaster  *gpRainDropSmallRaster;
+RwRaster  *gpBloodRaster;
+RwRaster  *gpLeafRaster;
+RwRaster  *gpCloudRaster1; // unused
+RwRaster  *gpCloudRaster4;
+RwRaster  *gpBloodSmallRaster;
+RwRaster  *gpGungeRaster;
+RwRaster  *gpCollisionSmokeRaster;
+RwRaster  *gpBulletHitRaster;
+RwRaster  *gpGunShellRaster;
+RwRaster  *gpWakeOldRaster;
+
+
+RwRaster  *gpPointlightRaster;	// CPointLights::RenderFogEffect
+
+RwTexture *gpRainDropTex[MAX_RAINDROP_FILES]; // CWeather::RenderRainStreaks
+
+
+RwRaster  *gpRainDropRaster[MAX_RAINDROP_FILES];
+
+float      CParticle::ms_afRandTable[CParticle::RAND_TABLE_SIZE];
+
+
+CParticle *CParticle::m_pUnusedListHead;
+
+
+float      CParticle::m_SinTable[CParticle::SIN_COS_TABLE_SIZE];
+float      CParticle::m_CosTable[CParticle::SIN_COS_TABLE_SIZE]; 
+
+int32 Randomizer;
+
+int32 nParticleCreationInterval = 1;
+float fParticleScaleLimit       = 0.5f;
+
+#ifdef DEBUGMENU
+SETTWEAKPATH("Particle");
+TWEAKINT32(nParticleCreationInterval, 0, 5, 1);
+TWEAKFLOAT(fParticleScaleLimit, 0.0f, 1.0f, 0.1f);
+TWEAKFUNC(CParticle::ReloadConfig);
+#endif
+
+void CParticle::ReloadConfig()
+{
+	debug("Initialising CParticleMgr...");
+	
+	mod_ParticleSystemManager.Initialise();
+	
+	debug("Initialising CParticle...");
+	
+	m_pUnusedListHead = gParticleArray;
+	
+	for ( int32 i = 0; i < MAX_PARTICLES_ON_SCREEN; i++ )
+	{
+		if ( i == MAX_PARTICLES_ON_SCREEN - 1 )
+			gParticleArray[i].m_pNext = nil;
+		else
+			gParticleArray[i].m_pNext = &gParticleArray[i + 1];
+		
+		gParticleArray[i].m_vecPosition = CVector(0.0f, 0.0f, 0.0f);
+
+		gParticleArray[i].m_vecVelocity = CVector(0.0f, 0.0f, 0.0f);
+
+		gParticleArray[i].m_nTimeWhenWillBeDestroyed = 0;
+
+		gParticleArray[i].m_nTimeWhenColorWillBeChanged = 0;
+
+		gParticleArray[i].m_fSize = 0.2f;
+
+		gParticleArray[i].m_fExpansionRate = 0.0f;
+
+		gParticleArray[i].m_nColorIntensity = 255;
+
+		gParticleArray[i].m_nFadeToBlackTimer = 0;
+
+		gParticleArray[i].m_nAlpha = 255;
+
+		gParticleArray[i].m_nFadeAlphaTimer = 0;
+
+		gParticleArray[i].m_nCurrentZRotation = 0;
+
+		gParticleArray[i].m_nZRotationTimer = 0;
+
+		gParticleArray[i].m_fCurrentZRadius = 0.0f;
+
+		gParticleArray[i].m_nZRadiusTimer = 0;
+
+		gParticleArray[i].m_nCurrentFrame = 0;
+
+		gParticleArray[i].m_nAnimationSpeedTimer = 0;
+
+		gParticleArray[i].m_nRotation = 0;
+
+		gParticleArray[i].m_nRotationStep = 0;
+	}
+}
+
+void CParticle::Initialise()
+{
+	ReloadConfig();
+
+	CParticleObject::Initialise();
+
+	float randVal = -1.0f;
+	for ( int32 i = 0; i < RAND_TABLE_SIZE; i++ )
+	{
+		ms_afRandTable[i] = randVal;
+		randVal += 0.1f;
+	}
+	
+	for ( int32 i = 0; i < SIN_COS_TABLE_SIZE; i++ )
+	{		
+		float angle = DEGTORAD(float(i) * float(360.0f / SIN_COS_TABLE_SIZE));
+
+		m_SinTable[i] = ::Sin(angle);
+		m_CosTable[i] = ::Cos(angle);
+	}
+	
+	int32 slot = CTxdStore::FindTxdSlot("particle");
+
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(slot);
+	
+	for ( int32 i = 0; i < MAX_SMOKE_FILES; i++ )
+	{
+		gpSmokeTex[i] = RwTextureRead(SmokeFiles[i], nil);
+		gpSmokeRaster[i] = RwTextureGetRaster(gpSmokeTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_SMOKE2_FILES; i++ )
+	{
+		gpSmoke2Tex[i] = RwTextureRead(Smoke2Files[i], nil);
+		gpSmoke2Raster[i] = RwTextureGetRaster(gpSmoke2Tex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_RUBBER_FILES; i++ )
+	{
+		gpRubberTex[i] = RwTextureRead(RubberFiles[i], nil);
+		gpRubberRaster[i] = RwTextureGetRaster(gpRubberTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINSPLASH_FILES; i++ )
+	{
+		gpRainSplashTex[i] = RwTextureRead(RainSplashFiles[i], nil);
+		gpRainSplashRaster[i] = RwTextureGetRaster(gpRainSplashTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_WATERSPRAY_FILES; i++ )
+	{
+		gpWatersprayTex[i] = RwTextureRead(WatersprayFiles[i], nil);
+		gpWatersprayRaster[i] = RwTextureGetRaster(gpWatersprayTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_EXPLOSIONMEDIUM_FILES; i++ )
+	{
+		gpExplosionMediumTex[i] = RwTextureRead(ExplosionMediumFiles[i], nil);
+		gpExplosionMediumRaster[i] = RwTextureGetRaster(gpExplosionMediumTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_GUNFLASH_FILES; i++ )
+	{
+		gpGunFlashTex[i] = RwTextureRead(GunFlashFiles[i], NULL);
+		gpGunFlashRaster[i] = RwTextureGetRaster(gpGunFlashTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINDROP_FILES; i++ )
+	{
+		gpRainDropTex[i] = RwTextureRead(RaindropFiles[i], nil);
+		gpRainDropRaster[i] = RwTextureGetRaster(gpRainDropTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINSPLASHUP_FILES; i++ )
+	{
+		gpRainSplashupTex[i] = RwTextureRead(RainSplashupFiles[i], nil);
+		gpRainSplashupRaster[i] = RwTextureGetRaster(gpRainSplashupTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_BIRDFRONT_FILES; i++ )
+	{
+		gpBirdfrontTex[i] = RwTextureRead(BirdfrontFiles[i], NULL);
+		gpBirdfrontRaster[i] = RwTextureGetRaster(gpBirdfrontTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_CARDEBRIS_FILES; i++ )
+	{
+		gpCarDebrisTex[i] = RwTextureRead(CardebrisFiles[i], nil);
+		gpCarDebrisRaster[i] = RwTextureGetRaster(gpCarDebrisTex[i]);
+	}
+	
+	for ( int32 i = 0; i < MAX_CARSPLASH_FILES; i++ )
+	{
+		gpCarSplashTex[i] = RwTextureRead(CarsplashFiles[i], nil);
+		gpCarSplashRaster[i] = RwTextureGetRaster(gpCarSplashTex[i]);
+	}
+
+	gpFlame1Tex = RwTextureRead("flame1", NULL);
+	gpFlame1Raster = RwTextureGetRaster(gpFlame1Tex);
+
+	gpFlame5Tex = RwTextureRead("flame5", nil);
+	
+//#ifdef FIX_BUGS
+#if 0
+	gpFlame5Raster = RwTextureGetRaster(gpFlame5Tex);
+#else
+	// this seems to have become more of a design choice
+	gpFlame5Raster = RwTextureGetRaster(gpFlame1Tex);	// copy-paste bug ?
+#endif
+
+	gpRainDropSmallTex = RwTextureRead("rainsmall", nil);
+	gpRainDropSmallRaster = RwTextureGetRaster(gpRainDropSmallTex);
+
+	gpBloodTex = RwTextureRead("blood", nil);
+	gpBloodRaster = RwTextureGetRaster(gpBloodTex);
+
+	gpLeafTex = RwTextureRead("gameleaf01_64", nil);
+	gpLeafRaster = RwTextureGetRaster(gpLeafTex);
+
+	gpCloudTex1 = RwTextureRead("cloud3", nil);
+	gpCloudRaster1 = RwTextureGetRaster(gpCloudTex1);
+
+	gpCloudTex4 = RwTextureRead("cloudmasked", nil);
+	gpCloudRaster4 = RwTextureGetRaster(gpCloudTex4);
+
+	gpBloodSmallTex = RwTextureRead("bloodsplat2", nil);
+	gpBloodSmallRaster = RwTextureGetRaster(gpBloodSmallTex);
+
+	gpGungeTex = RwTextureRead("gunge", nil);
+	gpGungeRaster = RwTextureGetRaster(gpGungeTex);
+
+	gpCollisionSmokeTex = RwTextureRead("collisionsmoke", nil);
+	gpCollisionSmokeRaster = RwTextureGetRaster(gpCollisionSmokeTex);
+
+	gpBulletHitTex = RwTextureRead("bullethitsmoke", nil);
+	gpBulletHitRaster = RwTextureGetRaster(gpBulletHitTex);
+
+	gpGunShellTex = RwTextureRead("gunshell", nil);
+	gpGunShellRaster = RwTextureGetRaster(gpGunShellTex);
+
+	gpWakeOldTex = RwTextureRead("wake_old", nil);
+	gpWakeOldRaster = RwTextureGetRaster(gpWakeOldTex);
+
+	gpPointlightTex = RwTextureRead("pointlight", nil);
+	gpPointlightRaster = RwTextureGetRaster(gpPointlightTex);
+	
+	CTxdStore::PopCurrentTxd();
+	
+	for ( int32 i = 0; i < MAX_PARTICLES; i++ )
+	{
+		tParticleSystemData *entry = &mod_ParticleSystemManager.m_aParticles[i];
+		
+		switch ( i )
+		{
+			case PARTICLE_BLOOD:
+				entry->m_ppRaster = &gpBloodRaster;
+				break;
+
+			case PARTICLE_BLOOD_SMALL:
+			case PARTICLE_BLOOD_SPURT:
+				entry->m_ppRaster = &gpBloodSmallRaster;
+				break;
+
+			case PARTICLE_DEBRIS2:
+				entry->m_ppRaster = &gpGungeRaster;
+				break;
+
+			case PARTICLE_GUNFLASH:
+			case PARTICLE_GUNFLASH_NOANIM:
+				entry->m_ppRaster = gpGunFlashRaster;
+				break;
+
+			case PARTICLE_GUNSMOKE:
+			case PARTICLE_SPLASH:
+				entry->m_ppRaster = nil;
+				break;
+
+			case PARTICLE_FLAME:
+			case PARTICLE_CARFLAME:
+				entry->m_ppRaster = &gpFlame1Raster;
+				break;
+
+			case PARTICLE_FIREBALL:
+				entry->m_ppRaster = &gpFlame5Raster;
+				break;
+
+			case PARTICLE_RAIN_SPLASH:
+			case PARTICLE_RAIN_SPLASH_BIGGROW:
+				entry->m_ppRaster = gpRainSplashRaster;
+				break;
+
+			case PARTICLE_RAIN_SPLASHUP:
+				entry->m_ppRaster = gpRainSplashupRaster;
+				break;
+
+			case PARTICLE_WATERSPRAY:
+				entry->m_ppRaster = gpWatersprayRaster;
+				break;
+
+			case PARTICLE_SHARD:
+			case PARTICLE_RAINDROP:
+			case PARTICLE_RAINDROP_2D:
+				entry->m_ppRaster = gpRainDropRaster;
+				break;
+
+			case PARTICLE_EXPLOSION_MEDIUM:
+			case PARTICLE_EXPLOSION_LARGE:
+			case PARTICLE_EXPLOSION_MFAST:
+			case PARTICLE_EXPLOSION_LFAST:
+				entry->m_ppRaster = gpExplosionMediumRaster;
+				break;
+
+			case PARTICLE_BOAT_WAKE:
+				entry->m_ppRaster = &gpWakeOldRaster;
+				break;
+
+			case PARTICLE_CAR_SPLASH:
+			case PARTICLE_WATER_HYDRANT:
+			case PARTICLE_PED_SPLASH:
+				entry->m_ppRaster = gpCarSplashRaster;
+				break;
+
+			case PARTICLE_SPARK:
+			case PARTICLE_SPARK_SMALL:
+			case PARTICLE_RAINDROP_SMALL:
+			case PARTICLE_HELI_ATTACK:
+				entry->m_ppRaster = &gpRainDropSmallRaster;
+				break;
+
+			case PARTICLE_DEBRIS:
+			case PARTICLE_TREE_LEAVES:
+				entry->m_ppRaster = &gpLeafRaster;
+				break;
+
+			case PARTICLE_CAR_DEBRIS:
+			case PARTICLE_HELI_DEBRIS:
+				entry->m_ppRaster = gpCarDebrisRaster;
+				break;
+
+			case PARTICLE_WHEEL_DIRT:
+			case PARTICLE_STEAM2:
+			case PARTICLE_STEAM_NY:
+			case PARTICLE_STEAM_NY_SLOWMOTION:
+			case PARTICLE_ENGINE_STEAM:
+			case PARTICLE_BOAT_THRUSTJET:
+			case PARTICLE_PEDFOOT_DUST:
+			case PARTICLE_EXHAUST_FUMES:
+				entry->m_ppRaster = gpSmoke2Raster;
+				break;
+
+			case PARTICLE_GUNSMOKE2:
+			case PARTICLE_RUBBER_SMOKE:
+				entry->m_ppRaster = gpRubberRaster;
+				break;
+
+			case PARTICLE_CARCOLLISION_DUST:
+			case PARTICLE_BURNINGRUBBER_SMOKE:
+				entry->m_ppRaster = &gpCollisionSmokeRaster;
+				break;
+
+			case PARTICLE_WHEEL_WATER:
+			case PARTICLE_WATER:
+			case PARTICLE_SMOKE:
+			case PARTICLE_SMOKE_SLOWMOTION:
+			case PARTICLE_GARAGEPAINT_SPRAY:
+			case PARTICLE_STEAM:
+			case PARTICLE_BOAT_SPLASH:
+			case PARTICLE_WATER_CANNON:
+			case PARTICLE_EXTINGUISH_STEAM:
+			case PARTICLE_HELI_DUST:
+			case PARTICLE_PAINT_SMOKE:
+			case PARTICLE_BULLETHIT_SMOKE:
+				entry->m_ppRaster = gpSmokeRaster;
+				break;
+
+			case PARTICLE_GUNSHELL_FIRST:
+			case PARTICLE_GUNSHELL:
+			case PARTICLE_GUNSHELL_BUMP1:
+			case PARTICLE_GUNSHELL_BUMP2:
+				entry->m_ppRaster = &gpGunShellRaster;
+				break;
+
+			case PARTICLE_ENGINE_SMOKE:
+			case PARTICLE_ENGINE_SMOKE2:
+			case PARTICLE_CARFLAME_SMOKE:
+			case PARTICLE_FIREBALL_SMOKE:
+			case PARTICLE_TEST:
+				entry->m_ppRaster = &gpCloudRaster4;
+				break;
+
+			case PARTICLE_BIRD_FRONT:
+				entry->m_ppRaster = gpBirdfrontRaster;
+				break;
+		}
+	}
+
+	debug("CParticle ready");
+}
+
+void
+CEntity::AddSteamsFromGround(CVector *unused)
+{
+	int i, n;
+	C2dEffect *effect;
+	CVector pos;
+
+	n = CModelInfo::GetModelInfo(GetModelIndex())->GetNum2dEffects();
+	for(i = 0; i < n; i++){
+		effect = CModelInfo::GetModelInfo(GetModelIndex())->Get2dEffect(i);
+		if(effect->type != EFFECT_PARTICLE)
+			continue;
+
+		pos = GetMatrix() * effect->pos;
+		switch(effect->particle.particleType){
+		case 0:
+			CParticleObject::AddObject(POBJECT_PAVEMENT_STEAM, pos, effect->particle.dir, effect->particle.scale, false);
+			break;
+		case 1:
+			CParticleObject::AddObject(POBJECT_WALL_STEAM, pos, effect->particle.dir, effect->particle.scale, false);
+			break;
+		case 2:
+			CParticleObject::AddObject(POBJECT_DRY_ICE, pos, effect->particle.scale, false);
+			break;
+		case 3:
+			CParticleObject::AddObject(POBJECT_SMALL_FIRE, pos, effect->particle.dir, effect->particle.scale, false);
+			break;
+		case 4:
+			CParticleObject::AddObject(POBJECT_DARK_SMOKE, pos, effect->particle.dir, effect->particle.scale, false);
+			break;
+		}
+	}
+}
+
+void CParticle::Shutdown()
+{
+	debug("Shutting down CParticle...");
+
+	for ( int32 i = 0; i < MAX_SMOKE_FILES; i++ )
+	{
+		RwTextureDestroy(gpSmokeTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpSmokeTex[i] = nil;
+#endif
+	}
+
+	for ( int32 i = 0; i < MAX_SMOKE2_FILES; i++ )
+	{
+		RwTextureDestroy(gpSmoke2Tex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpSmoke2Tex[i] = nil;
+#endif
+	}
+	 
+	for ( int32 i = 0; i < MAX_RUBBER_FILES; i++ )
+	{
+		RwTextureDestroy(gpRubberTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpRubberTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINSPLASH_FILES; i++ )
+	{
+		RwTextureDestroy(gpRainSplashTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpRainSplashTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_WATERSPRAY_FILES; i++ )
+	{
+		RwTextureDestroy(gpWatersprayTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpWatersprayTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_EXPLOSIONMEDIUM_FILES; i++ )
+	{
+		RwTextureDestroy(gpExplosionMediumTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpExplosionMediumTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_GUNFLASH_FILES; i++ )
+	{
+		RwTextureDestroy(gpGunFlashTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpGunFlashTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINDROP_FILES; i++ )
+	{
+		RwTextureDestroy(gpRainDropTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpRainDropTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_RAINSPLASHUP_FILES; i++ )
+	{
+		RwTextureDestroy(gpRainSplashupTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpRainSplashupTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_BIRDFRONT_FILES; i++ )
+	{
+		RwTextureDestroy(gpBirdfrontTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpBirdfrontTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_CARDEBRIS_FILES; i++ )
+	{
+		RwTextureDestroy(gpCarDebrisTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpCarDebrisTex[i] = nil;
+#endif
+	}
+	
+	for ( int32 i = 0; i < MAX_CARSPLASH_FILES; i++ )
+	{
+		RwTextureDestroy(gpCarSplashTex[i]);
+#if GTA_VERSION >= GTA3_PC_11
+		gpCarSplashTex[i] = nil;
+#endif
+	}
+	
+	RwTextureDestroy(gpFlame1Tex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpFlame1Tex = nil;
+#endif
+
+	RwTextureDestroy(gpFlame5Tex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpFlame5Tex = nil;
+#endif
+	
+	RwTextureDestroy(gpRainDropSmallTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpRainDropSmallTex = nil;
+#endif
+	
+	RwTextureDestroy(gpBloodTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpBloodTex = nil;
+#endif
+	
+	RwTextureDestroy(gpLeafTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpLeafTex = nil;
+#endif
+	
+	RwTextureDestroy(gpCloudTex1);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex1 = nil;
+#endif
+	
+	RwTextureDestroy(gpCloudTex4);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCloudTex4 = nil;
+#endif
+	
+	RwTextureDestroy(gpBloodSmallTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpBloodSmallTex = nil;
+#endif
+	
+	RwTextureDestroy(gpGungeTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpGungeTex = nil;
+#endif
+	
+	RwTextureDestroy(gpCollisionSmokeTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpCollisionSmokeTex = nil;
+#endif
+	
+	RwTextureDestroy(gpBulletHitTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpBulletHitTex = nil;
+#endif
+	
+	RwTextureDestroy(gpGunShellTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpGunShellTex = nil;
+#endif
+	
+	RwTextureDestroy(gpWakeOldTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpWakeOldTex = nil;
+#endif
+	
+	RwTextureDestroy(gpPointlightTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpPointlightTex = nil;
+#endif
+
+	int32 slot;
+
+	slot = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::RemoveTxdSlot(slot);
+
+	debug("CParticle shut down");
+}
+
+CParticle *CParticle::AddParticle(tParticleType type, CVector const &vecPos, CVector const &vecDir, CEntity *pEntity, float fSize, int32 nRotationSpeed, int32 nRotation, int32 nCurFrame, int32 nLifeSpan)
+{
+	CRGBA color(0, 0, 0, 0);
+	return AddParticle(type, vecPos, vecDir, pEntity, fSize, color, nRotationSpeed, nRotation, nCurFrame, nLifeSpan);
+}
+
+CParticle *CParticle::AddParticle(tParticleType type, CVector const &vecPos, CVector const &vecDir, CEntity *pEntity, float fSize, RwRGBA const &color, int32 nRotationSpeed, int32 nRotation, int32 nCurFrame, int32 nLifeSpan)
+{
+	if ( CTimer::GetIsPaused() )
+		return NULL;
+
+#ifdef PC_PARTICLE
+	if ( ( type == PARTICLE_ENGINE_SMOKE
+		|| type == PARTICLE_ENGINE_SMOKE2
+		|| type == PARTICLE_ENGINE_STEAM
+		|| type == PARTICLE_CARFLAME_SMOKE
+		|| type == PARTICLE_RUBBER_SMOKE
+		|| type == PARTICLE_BURNINGRUBBER_SMOKE
+		|| type == PARTICLE_EXHAUST_FUMES
+		|| type == PARTICLE_CARCOLLISION_DUST )
+		&& nParticleCreationInterval & CTimer::GetFrameCounter() )
+	{
+		return nil;
+	}
+#endif
+
+	CParticle *pParticle = m_pUnusedListHead;
+	
+	if ( pParticle == nil )
+		return nil;
+	
+	tParticleSystemData *psystem = &mod_ParticleSystemManager.m_aParticles[type];
+	
+	if ( psystem->m_fCreateRange != 0.0f && psystem->m_fCreateRange < ( TheCamera.GetPosition() - vecPos ).MagnitudeSqr() )
+		return nil;
+	
+	
+	pParticle->m_fSize = psystem->m_fDefaultInitialRadius;
+	pParticle->m_fExpansionRate = psystem->m_fExpansionRate;
+	
+	if ( nLifeSpan != 0 )
+		pParticle->m_nTimeWhenWillBeDestroyed = CTimer::GetTimeInMilliseconds() + nLifeSpan;
+	else
+		pParticle->m_nTimeWhenWillBeDestroyed = CTimer::GetTimeInMilliseconds() + psystem->m_nLifeSpan;
+
+	pParticle->m_nColorIntensity = psystem->m_nFadeToBlackInitialIntensity;
+	pParticle->m_nAlpha = psystem->m_nFadeAlphaInitialIntensity;
+	pParticle->m_nCurrentZRotation = psystem->m_nZRotationInitialAngle;
+	pParticle->m_fCurrentZRadius = psystem->m_fInitialZRadius;
+	
+	if ( nCurFrame != 0 )
+		pParticle->m_nCurrentFrame = nCurFrame;
+	else
+		pParticle->m_nCurrentFrame = psystem->m_nStartAnimationFrame;
+	
+	pParticle->m_nFadeToBlackTimer = 0;
+	pParticle->m_nFadeAlphaTimer = 0;
+	pParticle->m_nZRotationTimer = 0;
+	pParticle->m_nZRadiusTimer = 0;
+	pParticle->m_nAnimationSpeedTimer = 0;
+	pParticle->m_fZGround = 0.0f;
+	pParticle->m_vecPosition = vecPos;
+	pParticle->m_vecVelocity = vecDir;
+	pParticle->m_vecParticleMovementOffset = CVector(0.0f, 0.0f, 0.0f);
+	pParticle->m_nTimeWhenColorWillBeChanged = 0;
+	
+	if ( color.alpha != 0 )
+		RwRGBAAssign(&pParticle->m_Color, &color);
+	else
+	{
+		RwRGBAAssign(&pParticle->m_Color, &psystem->m_RenderColouring);
+
+		if ( psystem->m_ColorFadeTime != 0 )
+			pParticle->m_nTimeWhenColorWillBeChanged = CTimer::GetTimeInMilliseconds() + psystem->m_ColorFadeTime;
+
+		if ( psystem->m_InitialColorVariation != 0 )
+		{
+			int32 ColorVariation = CGeneral::GetRandomNumberInRange(-psystem->m_InitialColorVariation, psystem->m_InitialColorVariation);
+			//Float ColorVariation = CGeneral::GetRandomNumberInRange((float)-psystem->m_InitialColorVariation, (float)psystem->m_InitialColorVariation);
+  
+			pParticle->m_Color.red   = Clamp(pParticle->m_Color.red +
+				PERCENT(pParticle->m_Color.red, ColorVariation),
+				0, 255);
+			
+			pParticle->m_Color.green = Clamp(pParticle->m_Color.green +
+				PERCENT(pParticle->m_Color.green, ColorVariation),
+				0, 255);
+			
+			pParticle->m_Color.blue  = Clamp(pParticle->m_Color.blue +
+				PERCENT(pParticle->m_Color.blue, ColorVariation),
+				0, 255);
+		}
+	}
+
+	pParticle->m_nRotation = nRotation;
+	
+// PC only
+	if ( pParticle->m_nRotation >= 360 )
+		pParticle->m_nRotation -= 360;
+	else if ( pParticle->m_nRotation < 0 )
+		pParticle->m_nRotation += 360;
+	
+	if ( nRotationSpeed != 0 )
+		pParticle->m_nRotationStep = nRotationSpeed;
+	else
+		pParticle->m_nRotationStep = psystem->m_nRotationSpeed;
+	
+	if ( CGeneral::GetRandomNumber() & 1 )
+		pParticle->m_nRotationStep = -pParticle->m_nRotationStep;
+	
+	pParticle->m_vecScreenPosition.x = 0.0f; // bug ?
+	
+	if ( psystem->m_fPositionRandomError != 0.0f )
+	{
+		pParticle->m_vecPosition.x += psystem->m_fPositionRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+		pParticle->m_vecPosition.y += psystem->m_fPositionRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+		
+		if ( psystem->Flags & RAND_VERT_V )
+			pParticle->m_vecPosition.z += psystem->m_fPositionRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+	}
+	
+	if ( psystem->m_fVelocityRandomError != 0.0f )
+	{
+		pParticle->m_vecVelocity.x += psystem->m_fVelocityRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+		pParticle->m_vecVelocity.y += psystem->m_fVelocityRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+    
+		if ( psystem->Flags & RAND_VERT_V )
+			pParticle->m_vecVelocity.z += psystem->m_fVelocityRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+	}
+	
+	if ( psystem->m_fExpansionRateError != 0.0f )
+		pParticle->m_fExpansionRate += psystem->m_fExpansionRateError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE] + psystem->m_fExpansionRateError;
+	
+	if ( psystem->m_nRotationRateError != 0 )
+		pParticle->m_nRotationStep += CGeneral::GetRandomNumberInRange(-psystem->m_nRotationRateError, psystem->m_nRotationRateError);
+
+	if ( psystem->m_nLifeSpanErrorShape != 0 )
+	{
+		float randVal = ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+		if ( randVal > 0.0f )
+			pParticle->m_nTimeWhenWillBeDestroyed += int32(float(psystem->m_nLifeSpan) * randVal * float(psystem->m_nLifeSpanErrorShape));
+		else
+			pParticle->m_nTimeWhenWillBeDestroyed += int32(float(psystem->m_nLifeSpan) * randVal / float(psystem->m_nLifeSpanErrorShape));
+	}
+	
+	if ( psystem->Flags & ZCHECK_FIRST )
+	{
+		static bool bValidGroundFound = false;
+		static CVector LastTestCoors;
+		static float LastTestGroundZ;
+		
+		if ( bValidGroundFound 
+			&& vecPos.x == LastTestCoors.x 
+			&& vecPos.y == LastTestCoors.y 
+			&& vecPos.z == LastTestCoors.z )
+		{
+			pParticle->m_fZGround = LastTestGroundZ;
+		}
+		else
+		{
+			bValidGroundFound = false;
+			
+			CColPoint point;
+			CEntity *entity;
+			
+			if ( !CWorld::ProcessVerticalLine(
+						pParticle->m_vecPosition + CVector(0.0f, 0.0f, 0.5f),
+						-100.0f, point, entity, true, true, false, false, true, false, nil) )
+			{
+				return nil;
+			}
+			
+			if ( point.point.z >= pParticle->m_vecPosition.z )
+				return nil;
+			
+			pParticle->m_fZGround = point.point.z;
+			bValidGroundFound = true;
+			LastTestCoors = vecPos;
+			LastTestGroundZ = point.point.z;
+		}
+	}
+	
+	if ( psystem->Flags & ZCHECK_BUMP )
+	{
+		static float Z_Ground = 0.0f;
+		
+		if ( psystem->Flags & ZCHECK_BUMP_FIRST )
+		{
+			bool bZFound = false;
+
+			Z_Ground = CWorld::FindGroundZFor3DCoord(vecPos.x, vecPos.y, vecPos.z, (bool *)&bZFound);
+
+			if ( bZFound == false )
+				return nil;
+
+			pParticle->m_fZGround = Z_Ground;
+		}
+		
+		pParticle->m_fZGround = Z_Ground;
+	}
+	
+	switch ( type )
+	{
+		case PARTICLE_DEBRIS:
+			pParticle->m_vecVelocity.z *= CGeneral::GetRandomNumberInRange(0.5f, 3.0f);
+			break;
+		
+		case PARTICLE_EXPLOSION_MEDIUM:
+			pParticle->m_nColorIntensity -= 30 * (CGeneral::GetRandomNumber() & 1); // mb "+= -30 * rand" here ?
+			pParticle->m_nAnimationSpeedTimer = CGeneral::GetRandomNumber() & 7;
+			pParticle->m_fSize = CGeneral::GetRandomNumberInRange(0.3f, 0.8f);
+			pParticle->m_vecPosition.z -= CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+			break;
+		
+		case PARTICLE_EXPLOSION_LARGE:
+			pParticle->m_nColorIntensity -= 30 * (CGeneral::GetRandomNumber() & 1); // mb "+= -30 * rand" here ?
+			pParticle->m_nAnimationSpeedTimer = CGeneral::GetRandomNumber() & 7;
+			pParticle->m_fSize = CGeneral::GetRandomNumberInRange(0.8f, 1.4f);
+			pParticle->m_vecPosition.z -= CGeneral::GetRandomNumberInRange(-0.3f, 0.3f);
+			break;
+		
+		case PARTICLE_WATER_HYDRANT:
+			pParticle->m_vecPosition.z += 20.0f * psystem->m_fPositionRandomError * ms_afRandTable[CGeneral::GetRandomNumber() % RAND_TABLE_SIZE];
+			break;
+		default: break;
+	}
+	
+	if ( fSize != 0.0f )
+		pParticle->m_fSize = fSize;
+	
+	m_pUnusedListHead = pParticle->m_pNext;
+
+	pParticle->m_pNext = psystem->m_pParticles;
+
+	psystem->m_pParticles = pParticle;
+	
+	return pParticle;
+}
+
+void CParticle::Update()
+{
+	if ( CTimer::GetIsPaused() )
+		return;
+
+	CRGBA color(0, 0, 0, 0);
+	
+	float fFricDeccel50 = pow(0.50f, CTimer::GetTimeStep());
+	float fFricDeccel80 = pow(0.80f, CTimer::GetTimeStep());
+	float fFricDeccel90 = pow(0.90f, CTimer::GetTimeStep());
+	float fFricDeccel95 = pow(0.95f, CTimer::GetTimeStep());
+	float fFricDeccel96 = pow(0.96f, CTimer::GetTimeStep());
+	float fFricDeccel99 = pow(0.99f, CTimer::GetTimeStep());
+	
+	CParticleObject::UpdateAll();
+
+	for ( int32 i = 0; i < MAX_PARTICLES; i++ )
+	{
+		tParticleSystemData *psystem = &mod_ParticleSystemManager.m_aParticles[i];
+		CParticle *particle = psystem->m_pParticles;
+		CParticle *prevParticle = nil;
+		bool bRemoveParticle;
+		
+		if ( particle == nil )
+			continue;
+				
+		for ( ; particle != nil; _Next(particle, prevParticle, psystem, bRemoveParticle) )
+		{
+			bRemoveParticle = false;
+
+			CVector moveStep = particle->m_vecPosition + ( particle->m_vecVelocity * CTimer::GetTimeStep() );
+			
+			if (  CTimer::GetTimeInMilliseconds() > particle->m_nTimeWhenWillBeDestroyed || particle->m_nAlpha == 0 )
+			{
+				bRemoveParticle = true;
+				continue;
+			}
+
+			if ( particle->m_nTimeWhenColorWillBeChanged != 0 )
+			{
+				if ( particle->m_nTimeWhenColorWillBeChanged > CTimer::GetTimeInMilliseconds() )
+				{
+					float colorMul = 1.0f - float(particle->m_nTimeWhenColorWillBeChanged - CTimer::GetTimeInMilliseconds()) / float(psystem->m_ColorFadeTime);
+				
+					particle->m_Color.red = Clamp(
+						psystem->m_RenderColouring.red + int32(float(psystem->m_FadeDestinationColor.red - psystem->m_RenderColouring.red) * colorMul),
+						0, 255);
+					
+					particle->m_Color.green = Clamp(
+						psystem->m_RenderColouring.green + int32(float(psystem->m_FadeDestinationColor.green - psystem->m_RenderColouring.green) * colorMul),
+						0, 255);
+						
+					particle->m_Color.blue = Clamp(
+						psystem->m_RenderColouring.blue + int32(float(psystem->m_FadeDestinationColor.blue - psystem->m_RenderColouring.blue) * colorMul),
+						0, 255);
+				}
+				else
+					RwRGBAAssign(&particle->m_Color, &psystem->m_FadeDestinationColor);
+			}
+			
+			if ( psystem->Flags & CLIPOUT2D )
+			{
+				if ( particle->m_vecPosition.x < -10.0f || particle->m_vecPosition.x > SCREEN_WIDTH + 10.0f
+					|| particle->m_vecPosition.y < -10.0f || particle->m_vecPosition.y > SCREEN_HEIGHT + 10.0f )
+				{
+					bRemoveParticle = true;
+					continue;
+				}
+			}
+			
+			float size = particle->m_fSize + particle->m_fExpansionRate;
+			
+			if ( size < 0.0f )
+			{
+				bRemoveParticle = true;
+				continue;
+			}
+			
+			particle->m_fSize = size;
+			
+			switch ( psystem->m_nFrictionDecceleration )
+			{
+				case 50:
+					particle->m_vecVelocity *= fFricDeccel50;
+					break;
+		
+				case 80:
+					particle->m_vecVelocity *= fFricDeccel80;
+					break;
+		
+				case 90:
+					particle->m_vecVelocity *= fFricDeccel90;
+					break;
+		
+				case 95:
+					particle->m_vecVelocity *= fFricDeccel95;
+					break;
+		
+				case 96:
+					particle->m_vecVelocity *= fFricDeccel96;
+					break;
+		
+				case 99:
+					particle->m_vecVelocity *= fFricDeccel99;
+					break;				
+			}
+			
+			if ( psystem->m_fGravitationalAcceleration > 0.0f )
+			{
+				if ( -50.0f * psystem->m_fGravitationalAcceleration < particle->m_vecVelocity.z )
+					particle->m_vecVelocity.z -= psystem->m_fGravitationalAcceleration * CTimer::GetTimeStep();
+
+				if ( psystem->Flags & ZCHECK_FIRST )
+				{
+					if ( particle->m_vecPosition.z < particle->m_fZGround )
+					{
+						switch ( psystem->m_Type )
+						{
+							case PARTICLE_RAINDROP:
+							case PARTICLE_RAINDROP_SMALL:
+								{
+									bRemoveParticle = true;
+									
+									if ( CGeneral::GetRandomNumber() & 1 )
+									{
+										AddParticle(PARTICLE_RAIN_SPLASH,
+													CVector
+													(
+														particle->m_vecPosition.x,
+														particle->m_vecPosition.y,
+														0.05f + particle->m_fZGround
+													),
+													CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, 0, 0, 0, 0);
+									}
+									else
+									{
+										AddParticle(PARTICLE_RAIN_SPLASHUP,
+													CVector
+													(
+														particle->m_vecPosition.x,
+														particle->m_vecPosition.y,
+														0.05f + particle->m_fZGround
+													),
+													CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, 0, 0, 0, 0);
+									}
+									
+									continue;
+								}
+								break;
+
+							case PARTICLE_WHEEL_WATER:
+								{
+									bRemoveParticle = true;
+									
+									int32 randVal = CGeneral::GetRandomNumber();
+									
+									if ( randVal & 1 )
+									{
+										if ( (randVal % 5) == 0 )
+										{
+											AddParticle(PARTICLE_RAIN_SPLASH,
+														CVector
+														(
+															particle->m_vecPosition.x,
+															particle->m_vecPosition.y,
+															0.05f + particle->m_fZGround
+														),
+														CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, 0, 0, 0, 0);
+										}
+										else
+										{
+											AddParticle(PARTICLE_RAIN_SPLASHUP,
+														CVector
+														(
+															particle->m_vecPosition.x,
+															particle->m_vecPosition.y,
+															0.05f + particle->m_fZGround
+														),
+														CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, 0, 0, 0, 0);
+										}
+										
+									}
+									continue;
+								}
+								break;
+
+							case PARTICLE_BLOOD:
+							case PARTICLE_BLOOD_SMALL:
+								{
+									bRemoveParticle = true;
+									
+									CVector vecPosn = particle->m_vecPosition;
+									vecPosn.z += 1.0f;
+									
+									Randomizer++;
+									int32 randVal = int32(Randomizer & 7);
+									
+									if ( randVal == 5 )
+									{
+										CShadows::AddPermanentShadow(1, gpBloodPoolTex, &vecPosn,
+												0.1f, 0.0f, 0.0f, -0.1f,
+												255,
+												255, 0, 0,
+												4.0f, (CGeneral::GetRandomNumber() & 4095) + 2000, 1.0f);
+									}
+									else if ( randVal == 2 )
+									{
+										CShadows::AddPermanentShadow(1, gpBloodPoolTex, &vecPosn,
+												0.2f, 0.0f, 0.0f, -0.2f,
+												255,
+												255, 0, 0,
+												4.0f, (CGeneral::GetRandomNumber() & 4095) + 8000, 1.0f);
+									}
+									continue;
+								}
+								break;
+							default: break;
+						}
+					}
+				}
+				else if ( psystem->Flags & ZCHECK_STEP )
+				{
+					CColPoint point;
+					CEntity *entity;
+
+					if ( CWorld::ProcessVerticalLine(particle->m_vecPosition, moveStep.z, point, entity, 
+														true, true, false, false, true, false, nil) )
+					{
+						if ( moveStep.z <= point.point.z )
+						{
+							moveStep.z = point.point.z;
+							if ( psystem->m_Type == PARTICLE_DEBRIS2 )
+							{
+								particle->m_vecVelocity.x *= 0.8f;
+								particle->m_vecVelocity.y *= 0.8f;
+								particle->m_vecVelocity.z *= -0.4f;
+								if ( particle->m_vecVelocity.z < 0.005f )
+									particle->m_vecVelocity.z = 0.0f;
+							}
+						}
+					}
+				}
+				else if ( psystem->Flags & ZCHECK_BUMP )
+				{
+					if ( particle->m_vecPosition.z < particle->m_fZGround )
+					{
+						switch ( psystem->m_Type )
+						{
+							case PARTICLE_GUNSHELL_FIRST:
+							case PARTICLE_GUNSHELL:
+								{
+									bRemoveParticle = true;
+
+									AddParticle(PARTICLE_GUNSHELL_BUMP1,
+												CVector
+												(
+													particle->m_vecPosition.x,
+													particle->m_vecPosition.y,
+													0.05f + particle->m_fZGround
+												),
+												CVector
+												(
+													CGeneral::GetRandomNumberInRange(-0.02f, 0.02f),
+													CGeneral::GetRandomNumberInRange(-0.02f, 0.02f),
+													CGeneral::GetRandomNumberInRange(0.05f, 0.1f)
+												),
+												nil,
+												particle->m_fSize, color, particle->m_nRotationStep, 0, 0, 0);
+									
+									PlayOneShotScriptObject(SCRIPT_SOUND_GUNSHELL_DROP, particle->m_vecPosition);
+								}
+								break;
+							
+							case PARTICLE_GUNSHELL_BUMP1:
+								{
+									bRemoveParticle = true;
+									
+									AddParticle(PARTICLE_GUNSHELL_BUMP2,
+												CVector
+												(
+													particle->m_vecPosition.x,
+													particle->m_vecPosition.y,
+													0.05f + particle->m_fZGround
+												),
+												CVector(0.0f, 0.0f, CGeneral::GetRandomNumberInRange(0.03f, 0.06f)),
+												nil,
+												particle->m_fSize, color, 0, 0, 0, 0);
+									
+									PlayOneShotScriptObject(SCRIPT_SOUND_GUNSHELL_DROP_SOFT, particle->m_vecPosition);
+								}
+								break;
+								
+							case PARTICLE_GUNSHELL_BUMP2:
+								{
+									bRemoveParticle = true;
+									continue;
+								}
+								break;
+							default: break;
+						}
+					}
+				}
+			}
+			else
+			{
+				if ( psystem->m_fGravitationalAcceleration < 0.0f )
+				{
+					if ( -5.0f * psystem->m_fGravitationalAcceleration > particle->m_vecVelocity.z )
+						particle->m_vecVelocity.z -= psystem->m_fGravitationalAcceleration * CTimer::GetTimeStep();
+				}
+				else
+				{
+					if ( psystem->Flags & ZCHECK_STEP )
+					{
+						CColPoint point;
+						CEntity *entity;
+			
+						if ( CWorld::ProcessVerticalLine(particle->m_vecPosition, moveStep.z, point, entity,
+														true, false, false, false, true, false, nil) )
+						{
+							if ( moveStep.z <= point.point.z )
+							{
+								moveStep.z = point.point.z;
+								if ( psystem->m_Type == PARTICLE_HELI_ATTACK )
+								{
+									bRemoveParticle = true;
+									AddParticle(PARTICLE_STEAM, moveStep, CVector(0.0f, 0.0f, 0.05f), nil, 0.2f, 0, 0, 0, 0);
+									continue;
+								}
+							}
+						}
+					}
+				}
+			}
+
+			if ( psystem->m_nFadeToBlackAmount != 0 )
+			{
+				if ( particle->m_nFadeToBlackTimer >= psystem->m_nFadeToBlackTime )
+				{
+					particle->m_nFadeToBlackTimer = 0;
+					
+					particle->m_nColorIntensity = Clamp(particle->m_nColorIntensity - psystem->m_nFadeToBlackAmount,
+														0, 255);
+				}
+				else
+					++particle->m_nFadeToBlackTimer;
+			}
+
+			if ( psystem->m_nFadeAlphaAmount != 0 )
+			{
+				if ( particle->m_nFadeAlphaTimer >= psystem->m_nFadeAlphaTime )
+				{
+					particle->m_nFadeAlphaTimer = 0;
+					
+					particle->m_nAlpha = Clamp(particle->m_nAlpha - psystem->m_nFadeAlphaAmount,
+														0, 255);
+#ifdef PC_PARTICLE
+					if ( particle->m_nAlpha == 0 )
+					{
+						bRemoveParticle = true;
+						continue;
+					}
+#endif
+				}
+				else
+					++particle->m_nFadeAlphaTimer;
+			}
+			
+			if ( psystem->m_nZRotationAngleChangeAmount != 0 )
+			{
+				if ( particle->m_nZRotationTimer >= psystem->m_nZRotationChangeTime )
+				{
+					particle->m_nZRotationTimer = 0;
+					particle->m_nCurrentZRotation += psystem->m_nZRotationAngleChangeAmount;
+				}
+				else
+					++particle->m_nZRotationTimer;
+			}
+			
+			if ( psystem->m_fZRadiusChangeAmount != 0.0f )
+			{
+				if ( particle->m_nZRadiusTimer >= psystem->m_nZRadiusChangeTime )
+				{
+					particle->m_nZRadiusTimer = 0;
+					particle->m_fCurrentZRadius += psystem->m_fZRadiusChangeAmount;
+				}
+				else
+					++particle->m_nZRadiusTimer;
+			}
+
+			if ( psystem->m_nAnimationSpeed != 0 )
+			{
+				if ( particle->m_nAnimationSpeedTimer > psystem->m_nAnimationSpeed )
+				{
+					particle->m_nAnimationSpeedTimer = 0;
+					
+					if ( ++particle->m_nCurrentFrame > psystem->m_nFinalAnimationFrame )
+					{
+						if ( psystem->Flags & CYCLE_ANIM )
+							particle->m_nCurrentFrame = psystem->m_nStartAnimationFrame;
+						else
+							--particle->m_nCurrentFrame;
+					}	
+				}
+				else
+					++particle->m_nAnimationSpeedTimer;
+			}
+			
+			if ( particle->m_nRotationStep != 0 )
+			{
+				particle->m_nRotation += particle->m_nRotationStep;
+				
+				if ( particle->m_nRotation >= 360 )
+					particle->m_nRotation -= 360;
+				else if ( particle->m_nRotation < 0 )
+					particle->m_nRotation += 360;
+			}
+			
+			if ( particle->m_fCurrentZRadius != 0.0f )
+			{
+				int32 nRot = particle->m_nCurrentZRotation % (SIN_COS_TABLE_SIZE - 1);
+				
+				float fX = (Cos(nRot) - Sin(nRot)) * particle->m_fCurrentZRadius;
+				
+				float fY = (Sin(nRot) + Cos(nRot)) * particle->m_fCurrentZRadius;
+
+				moveStep -= particle->m_vecParticleMovementOffset;
+
+				moveStep += CVector(fX, fY, 0.0f);
+				
+				particle->m_vecParticleMovementOffset = CVector(fX, fY, 0.0f);
+			}
+			
+			particle->m_vecPosition = moveStep;
+		}
+	}
+}
+
+void CParticle::Render()
+{
+	PUSH_RENDERGROUP("CParticle::Render");
+
+	RwRenderStateSet(rwRENDERSTATETEXTUREADDRESS, (void *)rwTEXTUREADDRESSWRAP);
+	RwRenderStateSet(rwRENDERSTATETEXTUREPERSPECTIVE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+	
+	CSprite::InitSpriteBuffer2D();
+	
+	uint32 flags = DRAW_OPAQUE;
+	
+	RwRaster *prevFrame = nil;
+	
+	for ( int32 i = 0; i < MAX_PARTICLES; i++ )
+	{
+		tParticleSystemData *psystem = &mod_ParticleSystemManager.m_aParticles[i];
+#ifdef PC_PARTICLE
+		bool particleBanned = false;
+#endif
+		CParticle *particle = psystem->m_pParticles;
+		
+		RwRaster **frames = psystem->m_ppRaster;
+#ifdef PC_PARTICLE
+		tParticleType type = psystem->m_Type;
+
+		if ( type == PARTICLE_ENGINE_SMOKE
+			|| type == PARTICLE_ENGINE_SMOKE2
+			|| type == PARTICLE_ENGINE_STEAM
+			|| type == PARTICLE_CARFLAME_SMOKE
+			|| type == PARTICLE_RUBBER_SMOKE
+			|| type == PARTICLE_BURNINGRUBBER_SMOKE
+			|| type == PARTICLE_EXHAUST_FUMES
+			|| type == PARTICLE_CARCOLLISION_DUST )
+		{
+			particleBanned = true;
+		}
+#endif
+
+		if ( particle )
+		{
+			if ( (flags & DRAW_OPAQUE) != (psystem->Flags & DRAW_OPAQUE)
+				|| (flags & DRAW_DARK) != (psystem->Flags & DRAW_DARK) )
+			{
+				CSprite::FlushSpriteBuffer();
+				
+				if ( psystem->Flags & DRAW_OPAQUE )
+				{
+					RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+					RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+				}
+				else
+				{
+					if ( psystem->Flags & DRAW_DARK )
+						RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+					else
+						RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDONE);
+	
+					RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDONE);
+				}
+
+				flags = psystem->Flags;
+			}
+			
+			if ( frames != nil )
+			{
+				RwRaster *curFrame = *frames;
+				if ( curFrame != prevFrame )
+				{
+					CSprite::FlushSpriteBuffer();
+					RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)curFrame);
+					prevFrame = curFrame;
+				}
+			}
+		}
+		
+		while ( particle != nil )
+		{
+			bool canDraw = true;
+#ifdef PC_PARTICLE
+
+			if ( particle->m_nAlpha == 0 )
+				canDraw = false;
+#endif
+			if ( canDraw && psystem->m_nFinalAnimationFrame != 0 && frames != nil )
+			{
+				RwRaster *curFrame = frames[particle->m_nCurrentFrame];
+				if ( prevFrame != curFrame )
+				{
+					CSprite::FlushSpriteBuffer();
+					RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)curFrame);
+					prevFrame = curFrame;
+				}
+			}
+			
+			if ( canDraw && psystem->Flags & DRAWTOP2D )
+			{
+				if ( particle->m_nRotation != 0 )
+				{
+					 CSprite::RenderBufferedOneXLUSprite2D_Rotate_Dimension(
+							particle->m_vecPosition.x,
+							particle->m_vecPosition.y,
+							particle->m_fSize * 63.0f,
+							particle->m_fSize * 63.0f,
+							particle->m_Color,
+							particle->m_nColorIntensity,
+							(float)particle->m_nRotation, //DEGTORAD((float)particle->m_nRotation) ps2
+							particle->m_nAlpha);
+				}
+				else
+				{
+					CSprite::RenderBufferedOneXLUSprite2D(
+							particle->m_vecPosition.x,
+							particle->m_vecPosition.y,
+							particle->m_fSize * 63.0f,
+							particle->m_fSize * 63.0f,
+							particle->m_Color,
+							particle->m_nColorIntensity,
+							particle->m_nAlpha);
+				}
+				
+				canDraw = false;
+			}
+			
+			if ( canDraw )
+			{
+				CVector coors;
+				float w;
+				float h;
+
+				if ( CSprite::CalcScreenCoors(particle->m_vecPosition, &coors, &w, &h, true) )
+				{
+#ifdef PC_PARTICLE
+					if ( (!particleBanned || SCREEN_WIDTH * fParticleScaleLimit >= w)
+											&& SCREEN_HEIGHT * fParticleScaleLimit >= h )
+#endif
+					{
+						if ( particle->m_nRotation != 0 )
+						{					
+							CSprite::RenderBufferedOneXLUSprite_Rotate_Dimension(coors.x, coors.y, coors.z,
+									particle->m_fSize * w, particle->m_fSize * h,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									float(particle->m_nRotation), // DEGTORAD((float)particle->m_nRotation) ps2
+									particle->m_nAlpha);
+						}
+						else if ( psystem->Flags & SCREEN_TRAIL )
+						{
+							float fRotation;
+							float fTrailLength;
+							
+							if ( particle->m_vecScreenPosition.x == 0.0f )
+							{
+								fTrailLength = 0.0f;
+								fRotation = 0.0f;
+							}
+							else
+							{
+								CVector2D vecDist
+								(
+									coors.x - particle->m_vecScreenPosition.x,
+									coors.y - particle->m_vecScreenPosition.y
+								);
+
+								float fDist = vecDist.Magnitude();
+
+								fTrailLength = fDist;
+								
+								float fRot = Asin(vecDist.x / fDist);
+
+								fRotation = fRot;
+
+								if ( vecDist.y < 0.0f )
+									fRotation = -1.0f * fRot + DEGTORAD(180.0f);
+								
+								fRotation = RADTODEG(fRotation);
+	
+								if ( fRotation < 0.0f )
+									fRotation += 360.0f;
+								
+								float fSpeed = particle->m_vecVelocity.Magnitude();
+								
+								float fNewTrailLength = fSpeed * CTimer::GetTimeStep() * w * 2.0f;
+								
+								if ( fDist > fNewTrailLength )
+									fTrailLength = fNewTrailLength;
+							}
+							
+							CSprite::RenderBufferedOneXLUSprite_Rotate_Dimension(coors.x, coors.y, coors.z,
+									particle->m_fSize * w,
+									particle->m_fSize * h + fTrailLength * psystem->m_fTrailLengthMultiplier,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									fRotation,
+									particle->m_nAlpha);
+			
+							particle->m_vecScreenPosition = coors;
+						}
+						else if ( psystem->Flags & SPEED_TRAIL )
+						{
+							CVector vecPrevPos = particle->m_vecPosition - particle->m_vecVelocity;
+							float fRotation;
+							float fTrailLength;
+							
+							if ( CSprite::CalcScreenCoors(vecPrevPos, &particle->m_vecScreenPosition, &fTrailLength, &fRotation, true) )
+							{
+								CVector2D vecDist
+								(
+									coors.x - particle->m_vecScreenPosition.x,
+									coors.y - particle->m_vecScreenPosition.y
+								);
+								
+								float fDist = vecDist.Magnitude();
+								
+								fTrailLength = fDist;
+								
+								float fRot = Asin(vecDist.x / fDist);
+								
+								fRotation = fRot;
+								
+								if ( vecDist.y < 0.0f )
+									fRotation = -1.0f * fRot + DEGTORAD(180.0f);
+								
+								fRotation = RADTODEG(fRotation);
+								
+								if ( fRotation < 0.0f )
+									fRotation += 360.0f;
+							}
+							else
+							{
+								fRotation = 0.0f;
+								fTrailLength = 0.0f;
+							}
+							
+							CSprite::RenderBufferedOneXLUSprite_Rotate_Dimension(coors.x, coors.y, coors.z,
+									particle->m_fSize * w,
+									particle->m_fSize * h + fTrailLength * psystem->m_fTrailLengthMultiplier,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									fRotation,
+									particle->m_nAlpha);
+						}
+						else if ( psystem->Flags & VERT_TRAIL )
+						{
+							float fTrailLength = fabsf(particle->m_vecVelocity.z * 10.0f);
+
+							CSprite::RenderBufferedOneXLUSprite(coors.x, coors.y, coors.z,
+									particle->m_fSize * w,
+									(particle->m_fSize + fTrailLength * psystem->m_fTrailLengthMultiplier) * h,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									particle->m_nAlpha);
+						}
+						else if ( i == PARTICLE_RAINDROP_SMALL )
+						{
+							CSprite::RenderBufferedOneXLUSprite(coors.x, coors.y, coors.z,
+									particle->m_fSize * w * 0.05f,
+									particle->m_fSize * h,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									particle->m_nAlpha);
+						}
+						else if ( i == PARTICLE_BOAT_WAKE )
+						{
+							CSprite::RenderBufferedOneXLUSprite(coors.x, coors.y, coors.z,
+									particle->m_fSize * w,
+									psystem->m_fDefaultInitialRadius * h,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									particle->m_nAlpha);
+						}
+						else
+						{							
+							CSprite::RenderBufferedOneXLUSprite(coors.x, coors.y, coors.z,
+									particle->m_fSize * w,
+									particle->m_fSize * h,
+									particle->m_Color.red,
+									particle->m_Color.green,
+									particle->m_Color.blue,
+									particle->m_nColorIntensity,
+									1.0f / coors.z,
+									particle->m_nAlpha);
+						}
+					}
+				}
+			}
+			
+			particle = particle->m_pNext;
+		}
+
+		CSprite::FlushSpriteBuffer();
+
+	}
+	
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+
+	POP_RENDERGROUP();
+}
+
+void CParticle::RemovePSystem(tParticleType type)
+{
+	tParticleSystemData *psystemdata = &mod_ParticleSystemManager.m_aParticles[type];
+	
+	for ( CParticle *particle = psystemdata->m_pParticles; particle; particle = psystemdata->m_pParticles )
+		RemoveParticle(particle, nil, psystemdata);
+}
+
+void CParticle::RemoveParticle(CParticle *pParticle, CParticle *pPrevParticle, tParticleSystemData *pPSystemData)
+{
+	if ( pPrevParticle )
+		pPrevParticle->m_pNext = pParticle->m_pNext;
+	else
+		pPSystemData->m_pParticles = pParticle->m_pNext;
+
+	pParticle->m_pNext = m_pUnusedListHead;
+	m_pUnusedListHead = pParticle;
+}
+
+void CParticle::AddJetExplosion(CVector const &vecPos, float fPower, float fSize)
+{
+	CRGBA color(240, 240, 240, 255);
+
+	if ( fPower < 1.0f )
+		fPower = 1.0f;
+	
+	CVector vecRandOffset
+	(
+		CGeneral::GetRandomNumberInRange(-0.4f, 0.4f),
+		CGeneral::GetRandomNumberInRange(-0.4f, 0.4f),
+		CGeneral::GetRandomNumberInRange(0.1f, 0.3f)
+	);
+	
+	vecRandOffset *= 2.0f;
+
+	CVector vecStepPos = vecPos;
+
+	for ( int32 i = 0; i < int32(fPower * 4.0f); i++ )
+	{
+		AddParticle(PARTICLE_EXPLOSION_MFAST,
+					vecStepPos,
+					CVector
+					(
+						CGeneral::GetRandomNumberInRange(-0.02f, 0.02f),
+						CGeneral::GetRandomNumberInRange(-0.02f, 0.02f),
+						CGeneral::GetRandomNumberInRange(-0.02f, 0.0f)
+					),
+					nil,
+					fSize, color, 0, 0, 0, 0);
+
+		AddParticle(PARTICLE_EXPLOSION_MFAST,
+					vecStepPos,
+					CVector
+					(
+						CGeneral::GetRandomNumberInRange(-0.04f, 0.04f),
+						CGeneral::GetRandomNumberInRange(-0.04f, 0.04f),
+						CGeneral::GetRandomNumberInRange(0.0f, 0.07f)
+					),
+					nil,
+					fSize, color, 0, 0, 0, 0);
+
+		AddParticle(PARTICLE_EXPLOSION_MFAST,
+					vecStepPos,
+					CVector
+					(
+						CGeneral::GetRandomNumberInRange(-0.04f, 0.04f),
+						CGeneral::GetRandomNumberInRange(-0.04f, 0.04f),
+						CGeneral::GetRandomNumberInRange(0.0f, 0.07f)
+					),
+					nil,
+					fSize, color, 0, 0, 0, 0);
+		
+		vecStepPos += vecRandOffset;
+	}
+}
+
+void CParticle::AddYardieDoorSmoke(CVector const &vecPos, CMatrix const &matMatrix)
+{
+	CRGBA color(0, 0, 0, 0);
+	
+	CMatrix invMat(Invert(matMatrix));
+	
+	CVector vecBasePos = matMatrix * (invMat * vecPos + CVector(0.0f, -1.0f, 0.5f));
+	
+	for ( int32 i = 0; i < 5; i++ )
+	{
+		CVector pos = vecBasePos;
+
+		pos.x += CGeneral::GetRandomNumberInRange(-0.5f, 0.5f);
+		pos.y += CGeneral::GetRandomNumberInRange(-0.5f, 0.5f);
+		
+		AddParticle(PARTICLE_CARCOLLISION_DUST,
+					pos,
+					CVector(0.0f, 0.0f, 0.0f),
+					nil,
+					0.3f, color, 0, 0, 0, 0);
+	}
+}
diff --git a/src/renderer/Particle.h b/src/renderer/Particle.h
new file mode 100644
index 00000000..7f02e318
--- /dev/null
+++ b/src/renderer/Particle.h
@@ -0,0 +1,94 @@
+#pragma once
+#include "ParticleMgr.h"
+
+
+class CEntity;
+
+class CParticle
+{
+public:
+	enum
+	{
+		RAND_TABLE_SIZE    = 20,
+		SIN_COS_TABLE_SIZE = 1024
+	};
+
+	CVector   m_vecPosition;
+	CVector   m_vecVelocity;
+	CVector   m_vecScreenPosition;
+	uint32     m_nTimeWhenWillBeDestroyed;
+	uint32     m_nTimeWhenColorWillBeChanged;
+	float     m_fZGround;
+	CVector   m_vecParticleMovementOffset;
+	int16     m_nCurrentZRotation;
+	uint16     m_nZRotationTimer;
+	float     m_fCurrentZRadius;
+	uint16     m_nZRadiusTimer;
+	float     m_fSize;
+	float     m_fExpansionRate;
+	uint16     m_nFadeToBlackTimer;
+	uint16     m_nFadeAlphaTimer;
+	uint8     m_nColorIntensity;
+	uint8     m_nAlpha;
+	uint16    m_nCurrentFrame;
+	int16     m_nAnimationSpeedTimer;
+	int16     m_nRotationStep;
+	int16     m_nRotation;
+	RwRGBA    m_Color;
+	CParticle *m_pNext;
+	
+	CParticle()
+	{
+		;
+	}
+	
+	~CParticle()
+	{
+		;
+	}
+
+	static float      ms_afRandTable[RAND_TABLE_SIZE];
+	static CParticle *m_pUnusedListHead;
+	
+	static float      m_SinTable[SIN_COS_TABLE_SIZE];
+	static float      m_CosTable[SIN_COS_TABLE_SIZE];
+	
+	static float Sin(int32 value) { return m_SinTable[value]; }
+	static float Cos(int32 value) { return m_CosTable[value]; }
+	
+	static void ReloadConfig();
+	static void Initialise();
+	static void Shutdown();
+	
+	static CParticle *AddParticle(tParticleType type, CVector const &vecPos, CVector const &vecDir, CEntity *pEntity = nil, float fSize = 0.0f, int32 nRotationSpeed = 0, int32 nRotation = 0, int32 nCurFrame = 0, int32 nLifeSpan = 0);
+	static CParticle *AddParticle(tParticleType type, CVector const &vecPos, CVector const &vecDir, CEntity *pEntity, float fSize, RwRGBA const &color, int32 nRotationSpeed = 0, int32 nRotation = 0, int32 nCurFrame = 0, int32 nLifeSpan = 0);
+
+	static void Update();
+	static void Render();
+
+	static void RemovePSystem(tParticleType type);
+	static void RemoveParticle(CParticle *pParticle, CParticle *pPrevParticle, tParticleSystemData *pPSystemData);
+	
+	static void _Next(CParticle *&pParticle, CParticle *&pPrevParticle, tParticleSystemData *pPSystemData, bool bRemoveParticle)
+	{
+		if ( bRemoveParticle )
+		{
+			RemoveParticle(pParticle, pPrevParticle, pPSystemData);
+					
+			if ( pPrevParticle )
+				pParticle = pPrevParticle->m_pNext;
+			else
+				pParticle = pPSystemData->m_pParticles;
+		}
+		else
+		{
+			pPrevParticle = pParticle;
+			pParticle = pParticle->m_pNext;
+		}
+	}
+
+	static void AddJetExplosion(CVector const &vecPos, float fPower, float fSize);
+	static void AddYardieDoorSmoke(CVector const &vecPos, CMatrix const &matMatrix);
+};
+
+VALIDATE_SIZE(CParticle, 0x68);
diff --git a/src/renderer/ParticleMgr.cpp b/src/renderer/ParticleMgr.cpp
new file mode 100644
index 00000000..3387d471
--- /dev/null
+++ b/src/renderer/ParticleMgr.cpp
@@ -0,0 +1,243 @@
+#include "common.h"
+
+#include "main.h"
+#include "FileMgr.h"
+#include "ParticleMgr.h"
+
+cParticleSystemMgr mod_ParticleSystemManager;
+
+const char *ParticleFilename = "PARTICLE.CFG";
+
+cParticleSystemMgr::cParticleSystemMgr()
+{
+	memset(this, 0, sizeof(*this));
+}
+
+void cParticleSystemMgr::Initialise()
+{
+	LoadParticleData();
+	
+	for ( int32 i = 0; i < MAX_PARTICLES; i++ )
+		m_aParticles[i].m_pParticles = nil;
+}
+
+void cParticleSystemMgr::LoadParticleData()
+{
+	CFileMgr::SetDir("DATA");
+	CFileMgr::LoadFile(ParticleFilename, work_buff, ARRAY_SIZE(work_buff), "r");
+	CFileMgr::SetDir("");
+	
+	tParticleSystemData *entry = nil;
+	int32 type = PARTICLE_FIRST;
+	
+	char *lineStart = (char *)work_buff;
+	char *lineEnd = lineStart + 1;
+	
+	char line[500];
+	char delims[4];
+
+	while ( true )
+	{
+		ASSERT(lineStart != nil);
+		ASSERT(lineEnd != nil);
+		
+		while ( *lineEnd != '\n' )
+			++lineEnd;
+		
+		int32 lineLength = lineEnd - lineStart;
+		
+		ASSERT(lineLength < 500);
+
+		strncpy(line, lineStart, lineLength);
+		
+		line[lineLength] = '\0';
+		
+		if ( !strcmp(line, ";the end") )
+			break;
+		
+		if ( *line != ';' )
+		{
+			int32 param = CFG_PARAM_FIRST;
+
+			strcpy(delims, " \t");
+			
+			char *value = strtok(line, delims);
+			
+			ASSERT(value != nil);
+			
+			do
+			{	
+				switch ( param )
+				{
+					case CFG_PARAM_PARTICLE_TYPE_NAME:
+						ASSERT(type < MAX_PARTICLES);
+						entry = &m_aParticles[type];
+						ASSERT(entry != nil);
+						entry->m_Type = (tParticleType)type++;
+						strcpy(entry->m_aName, value);
+						break;
+
+					case CFG_PARAM_RENDER_COLOURING_R:
+						entry->m_RenderColouring.red = atoi(value);
+						break;
+
+					case CFG_PARAM_RENDER_COLOURING_G:
+						entry->m_RenderColouring.green = atoi(value);
+						break;
+
+					case CFG_PARAM_RENDER_COLOURING_B:
+						entry->m_RenderColouring.blue = atoi(value);
+						break;
+
+					case CFG_PARAM_INITIAL_COLOR_VARIATION:
+						entry->m_InitialColorVariation = Min(atoi(value), 100);
+						break;
+
+					case CFG_PARAM_FADE_DESTINATION_COLOR_R:
+						entry->m_FadeDestinationColor.red = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_DESTINATION_COLOR_G:
+						entry->m_FadeDestinationColor.green = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_DESTINATION_COLOR_B:
+						entry->m_FadeDestinationColor.blue = atoi(value);
+						break;
+
+					case CFG_PARAM_COLOR_FADE_TIME:
+						entry->m_ColorFadeTime = atoi(value);
+						break;
+
+					case CFG_PARAM_DEFAULT_INITIAL_RADIUS:
+						entry->m_fDefaultInitialRadius = atof(value);
+						break;
+
+					case CFG_PARAM_EXPANSION_RATE:
+						entry->m_fExpansionRate = atof(value);
+						break;
+
+					case CFG_PARAM_INITIAL_INTENSITY:
+						entry->m_nFadeToBlackInitialIntensity = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_TIME:
+						entry->m_nFadeToBlackTime = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_AMOUNT:
+						entry->m_nFadeToBlackAmount = atoi(value);
+						break;
+
+					case CFG_PARAM_INITIAL_ALPHA_INTENSITY:
+						entry->m_nFadeAlphaInitialIntensity = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_ALPHA_TIME:
+						entry->m_nFadeAlphaTime = atoi(value);
+						break;
+
+					case CFG_PARAM_FADE_ALPHA_AMOUNT:
+						entry->m_nFadeAlphaAmount = atoi(value);
+						break;
+
+					case CFG_PARAM_INITIAL_ANGLE:
+						entry->m_nZRotationInitialAngle = atoi(value);
+						break;
+
+					case CFG_PARAM_CHANGE_TIME:
+						entry->m_nZRotationChangeTime = atoi(value);
+						break;
+
+					case CFG_PARAM_ANGLE_CHANGE_AMOUNT:
+						entry->m_nZRotationAngleChangeAmount = atoi(value);
+						break;
+
+					case CFG_PARAM_INITIAL_Z_RADIUS:
+						entry->m_fInitialZRadius = atof(value);
+						break;
+
+					case CFG_PARAM_Z_RADIUS_CHANGE_TIME:
+						entry->m_nZRadiusChangeTime = atoi(value);
+						break;
+
+					case CFG_PARAM_Z_RADIUS_CHANGE_AMOUNT:
+						entry->m_fZRadiusChangeAmount = atof(value);
+						break;
+
+					case CFG_PARAM_ANIMATION_SPEED:
+						entry->m_nAnimationSpeed = atoi(value);
+						break;
+
+					case CFG_PARAM_START_ANIMATION_FRAME:
+						entry->m_nStartAnimationFrame = atoi(value);
+						break;
+
+					case CFG_PARAM_FINAL_ANIMATION_FRAME:
+						entry->m_nFinalAnimationFrame = atoi(value);
+						break;
+
+					case CFG_PARAM_ROTATION_SPEED:
+						entry->m_nRotationSpeed = atoi(value);
+						break;
+
+					case CFG_PARAM_GRAVITATIONAL_ACCELERATION:
+						entry->m_fGravitationalAcceleration = atof(value);
+						break;
+
+					case CFG_PARAM_FRICTION_DECCELERATION:
+						entry->m_nFrictionDecceleration = atoi(value);
+						break;
+
+					case CFG_PARAM_LIFE_SPAN:
+						entry->m_nLifeSpan = atoi(value);
+						break;
+
+					case CFG_PARAM_POSITION_RANDOM_ERROR:
+						entry->m_fPositionRandomError = atof(value);
+						break;
+
+					case CFG_PARAM_VELOCITY_RANDOM_ERROR:
+						entry->m_fVelocityRandomError = atof(value);
+						break;
+
+					case CFG_PARAM_EXPANSION_RATE_ERROR:
+						entry->m_fExpansionRateError = atof(value);
+						break;
+
+					case CFG_PARAM_ROTATION_RATE_ERROR:
+						entry->m_nRotationRateError = atoi(value);
+						break;
+
+					case CFG_PARAM_LIFE_SPAN_ERROR_SHAPE:
+						entry->m_nLifeSpanErrorShape = atoi(value);
+						break;
+
+					case CFG_PARAM_TRAIL_LENGTH_MULTIPLIER:
+						entry->m_fTrailLengthMultiplier = atof(value);
+						break;
+
+					case CFG_PARAM_PARTICLE_CREATE_RANGE:
+						entry->m_fCreateRange = SQR(atof(value));
+						break;
+
+					case CFG_PARAM_FLAGS:
+						entry->Flags = atoi(value);
+						break;
+				}
+				
+				value = strtok(nil, delims);
+
+				param++;
+
+				if ( param > CFG_PARAM_LAST )
+					param = CFG_PARAM_FIRST;
+		
+			} while ( value != nil );
+		}
+		
+		lineEnd++;
+		lineStart = lineEnd;
+		lineEnd++;
+	}
+}
diff --git a/src/renderer/ParticleMgr.h b/src/renderer/ParticleMgr.h
new file mode 100644
index 00000000..0100bb65
--- /dev/null
+++ b/src/renderer/ParticleMgr.h
@@ -0,0 +1,130 @@
+#pragma once
+
+#include "ParticleType.h"
+
+class CParticle;
+
+enum
+{
+	ZCHECK_FIRST      = BIT(0),
+	ZCHECK_STEP       = BIT(1),
+	DRAW_OPAQUE       = BIT(2),
+	SCREEN_TRAIL      = BIT(3),
+	SPEED_TRAIL       = BIT(4),
+	RAND_VERT_V       = BIT(5),
+	CYCLE_ANIM        = BIT(6),
+	DRAW_DARK         = BIT(7),
+	VERT_TRAIL        = BIT(8),
+	_FLAG9            = BIT(9),		// unused
+	DRAWTOP2D         = BIT(10),
+	CLIPOUT2D         = BIT(11),
+	ZCHECK_BUMP       = BIT(12),
+	ZCHECK_BUMP_FIRST = BIT(13)
+};
+
+
+struct tParticleSystemData
+{
+	tParticleType m_Type;
+	char          m_aName[20];
+	float         m_fCreateRange;
+	float         m_fDefaultInitialRadius;
+	float         m_fExpansionRate;
+	uint16        m_nZRotationInitialAngle;
+	int16         m_nZRotationAngleChangeAmount;
+	uint16        m_nZRotationChangeTime;
+	uint16        m_nZRadiusChangeTime;
+	float         m_fInitialZRadius;
+	float         m_fZRadiusChangeAmount;
+	uint16        m_nFadeToBlackTime;
+	int16         m_nFadeToBlackAmount;
+	uint8         m_nFadeToBlackInitialIntensity;
+	uint8         m_nFadeAlphaInitialIntensity;
+	uint16        m_nFadeAlphaTime;
+	int16         m_nFadeAlphaAmount;
+	uint16        m_nStartAnimationFrame;
+	uint16        m_nFinalAnimationFrame;
+	uint16        m_nAnimationSpeed;
+	uint16        m_nRotationSpeed;
+	float         m_fGravitationalAcceleration;
+	int32         m_nFrictionDecceleration;
+	int32         m_nLifeSpan;
+	float         m_fPositionRandomError;
+	float         m_fVelocityRandomError;
+	float         m_fExpansionRateError;
+	int32         m_nRotationRateError;
+	uint32        m_nLifeSpanErrorShape;
+	float         m_fTrailLengthMultiplier;
+	uint32        Flags;
+	RwRGBA        m_RenderColouring;
+	uint8         m_InitialColorVariation;
+	RwRGBA        m_FadeDestinationColor;
+	uint32        m_ColorFadeTime;
+
+	RwRaster      **m_ppRaster;
+	CParticle     *m_pParticles;
+};
+
+VALIDATE_SIZE(tParticleSystemData, 0x88);
+
+class cParticleSystemMgr
+{
+	enum
+	{
+		CFG_PARAM_PARTICLE_TYPE_NAME = 0,
+		CFG_PARAM_RENDER_COLOURING_R,
+		CFG_PARAM_RENDER_COLOURING_G,
+		CFG_PARAM_RENDER_COLOURING_B,
+		CFG_PARAM_INITIAL_COLOR_VARIATION,
+		CFG_PARAM_FADE_DESTINATION_COLOR_R,
+		CFG_PARAM_FADE_DESTINATION_COLOR_G,
+		CFG_PARAM_FADE_DESTINATION_COLOR_B,
+		CFG_PARAM_COLOR_FADE_TIME,
+		CFG_PARAM_DEFAULT_INITIAL_RADIUS,
+		CFG_PARAM_EXPANSION_RATE,
+		CFG_PARAM_INITIAL_INTENSITY,
+		CFG_PARAM_FADE_TIME,
+		CFG_PARAM_FADE_AMOUNT,
+		CFG_PARAM_INITIAL_ALPHA_INTENSITY,
+		CFG_PARAM_FADE_ALPHA_TIME,
+		CFG_PARAM_FADE_ALPHA_AMOUNT,
+		CFG_PARAM_INITIAL_ANGLE,
+		CFG_PARAM_CHANGE_TIME,
+		CFG_PARAM_ANGLE_CHANGE_AMOUNT,
+		CFG_PARAM_INITIAL_Z_RADIUS,
+		CFG_PARAM_Z_RADIUS_CHANGE_TIME,
+		CFG_PARAM_Z_RADIUS_CHANGE_AMOUNT,
+		CFG_PARAM_ANIMATION_SPEED,
+		CFG_PARAM_START_ANIMATION_FRAME,
+		CFG_PARAM_FINAL_ANIMATION_FRAME,
+		CFG_PARAM_ROTATION_SPEED,
+		CFG_PARAM_GRAVITATIONAL_ACCELERATION,
+		CFG_PARAM_FRICTION_DECCELERATION,
+		CFG_PARAM_LIFE_SPAN,
+		CFG_PARAM_POSITION_RANDOM_ERROR,
+		CFG_PARAM_VELOCITY_RANDOM_ERROR,
+		CFG_PARAM_EXPANSION_RATE_ERROR,
+		CFG_PARAM_ROTATION_RATE_ERROR,
+		CFG_PARAM_LIFE_SPAN_ERROR_SHAPE,
+		CFG_PARAM_TRAIL_LENGTH_MULTIPLIER,
+		CFG_PARAM_PARTICLE_CREATE_RANGE,
+		CFG_PARAM_FLAGS,
+
+		MAX_CFG_PARAMS,
+		CFG_PARAM_FIRST = CFG_PARAM_PARTICLE_TYPE_NAME,
+		CFG_PARAM_LAST = CFG_PARAM_FLAGS
+	};
+
+public:
+	tParticleSystemData m_aParticles[MAX_PARTICLES];
+
+	cParticleSystemMgr();
+
+	void Initialise();
+	void LoadParticleData();
+	void RangeCheck(tParticleSystemData *pData) { }
+};
+
+VALIDATE_SIZE(cParticleSystemMgr, 0x2420);
+
+extern cParticleSystemMgr mod_ParticleSystemManager;
diff --git a/src/renderer/ParticleType.h b/src/renderer/ParticleType.h
new file mode 100644
index 00000000..8d352c44
--- /dev/null
+++ b/src/renderer/ParticleType.h
@@ -0,0 +1,77 @@
+#pragma once
+
+enum tParticleType
+{
+	PARTICLE_SPARK = 0,
+	PARTICLE_SPARK_SMALL,
+	PARTICLE_WHEEL_DIRT,
+	PARTICLE_WHEEL_WATER,
+	PARTICLE_BLOOD,
+	PARTICLE_BLOOD_SMALL,
+	PARTICLE_BLOOD_SPURT,
+	PARTICLE_DEBRIS,
+	PARTICLE_DEBRIS2,
+	PARTICLE_WATER,
+	PARTICLE_FLAME,
+	PARTICLE_FIREBALL,
+	PARTICLE_GUNFLASH,
+	PARTICLE_GUNFLASH_NOANIM,
+	PARTICLE_GUNSMOKE,
+	PARTICLE_GUNSMOKE2,
+	PARTICLE_SMOKE,
+	PARTICLE_SMOKE_SLOWMOTION,
+	PARTICLE_GARAGEPAINT_SPRAY,
+	PARTICLE_SHARD,
+	PARTICLE_SPLASH,
+	PARTICLE_CARFLAME,
+	PARTICLE_STEAM,
+	PARTICLE_STEAM2,
+	PARTICLE_STEAM_NY,
+	PARTICLE_STEAM_NY_SLOWMOTION,
+	PARTICLE_ENGINE_STEAM,
+	PARTICLE_RAINDROP,
+	PARTICLE_RAINDROP_SMALL,
+	PARTICLE_RAIN_SPLASH,
+	PARTICLE_RAIN_SPLASH_BIGGROW,
+	PARTICLE_RAIN_SPLASHUP,
+	PARTICLE_WATERSPRAY,
+	PARTICLE_EXPLOSION_MEDIUM,
+	PARTICLE_EXPLOSION_LARGE,
+	PARTICLE_EXPLOSION_MFAST,
+	PARTICLE_EXPLOSION_LFAST,
+	PARTICLE_CAR_SPLASH,
+	PARTICLE_BOAT_SPLASH,
+	PARTICLE_BOAT_THRUSTJET,
+	PARTICLE_BOAT_WAKE,
+	PARTICLE_WATER_HYDRANT,
+	PARTICLE_WATER_CANNON,
+	PARTICLE_EXTINGUISH_STEAM,
+	PARTICLE_PED_SPLASH,
+	PARTICLE_PEDFOOT_DUST,
+	PARTICLE_HELI_DUST,
+	PARTICLE_HELI_ATTACK,
+	PARTICLE_ENGINE_SMOKE,
+	PARTICLE_ENGINE_SMOKE2,
+	PARTICLE_CARFLAME_SMOKE,
+	PARTICLE_FIREBALL_SMOKE,
+	PARTICLE_PAINT_SMOKE,
+	PARTICLE_TREE_LEAVES,
+	PARTICLE_CARCOLLISION_DUST,
+	PARTICLE_CAR_DEBRIS,
+	PARTICLE_HELI_DEBRIS,
+	PARTICLE_EXHAUST_FUMES,
+	PARTICLE_RUBBER_SMOKE,
+	PARTICLE_BURNINGRUBBER_SMOKE,
+	PARTICLE_BULLETHIT_SMOKE,
+	PARTICLE_GUNSHELL_FIRST,
+	PARTICLE_GUNSHELL,
+	PARTICLE_GUNSHELL_BUMP1,
+	PARTICLE_GUNSHELL_BUMP2,
+	PARTICLE_TEST,
+	PARTICLE_BIRD_FRONT,
+	PARTICLE_RAINDROP_2D,
+	
+	MAX_PARTICLES,
+	PARTICLE_FIRST = PARTICLE_SPARK,
+	PARTICLE_LAST = PARTICLE_RAINDROP_2D
+};
\ No newline at end of file
diff --git a/src/renderer/PlayerSkin.cpp b/src/renderer/PlayerSkin.cpp
new file mode 100644
index 00000000..f0fae45a
--- /dev/null
+++ b/src/renderer/PlayerSkin.cpp
@@ -0,0 +1,166 @@
+#include "common.h"
+
+#include "main.h"
+#include "PlayerSkin.h"
+#include "TxdStore.h"
+#include "rtbmp.h"
+#include "ClumpModelInfo.h"
+#include "VisibilityPlugins.h"
+#include "World.h"
+#include "PlayerInfo.h"
+#include "CdStream.h"
+#include "FileMgr.h"
+#include "Directory.h"
+#include "RwHelper.h"
+#include "Timer.h"
+#include "Lights.h"
+#include "MemoryMgr.h"
+
+RpClump *gpPlayerClump;
+float gOldFov;
+
+int CPlayerSkin::m_txdSlot;
+
+void
+FindPlayerDff(uint32 &offset, uint32 &size)
+{
+	int file;
+	CDirectory::DirectoryInfo info;
+
+	file = CFileMgr::OpenFile("models\\gta3.dir", "rb");
+
+	do {
+		if (!CFileMgr::Read(file, (char*)&info, sizeof(CDirectory::DirectoryInfo)))
+			return;
+	} while (strcasecmp("player.dff", info.name) != 0);
+
+	offset = info.offset;
+	size = info.size;
+}
+
+void
+LoadPlayerDff(void)
+{
+	RwStream *stream;
+	RwMemory mem;
+	uint32 offset, size;
+	uint8 *buffer;
+	bool streamWasAdded = false;
+
+	if (CdStreamGetNumImages() == 0) {
+		CdStreamAddImage("models\\gta3.img");
+		streamWasAdded = true;
+	}
+
+	FindPlayerDff(offset, size);
+	buffer = (uint8*)RwMallocAlign(size << 11, 2048);
+	CdStreamRead(0, buffer, offset, size);
+	CdStreamSync(0);
+
+	mem.start = buffer;
+	mem.length = size << 11;
+	stream = RwStreamOpen(rwSTREAMMEMORY, rwSTREAMREAD, &mem);
+
+	if (RwStreamFindChunk(stream, rwID_CLUMP, nil, nil))
+		gpPlayerClump = RpClumpStreamRead(stream);
+
+	RwStreamClose(stream, &mem);
+	RwFreeAlign(buffer);
+
+	if (streamWasAdded)
+		CdStreamRemoveImages();
+}
+
+void
+CPlayerSkin::Initialise(void)
+{
+	m_txdSlot = CTxdStore::AddTxdSlot("skin");
+	CTxdStore::Create(m_txdSlot);
+	CTxdStore::AddRef(m_txdSlot);
+}
+
+void
+CPlayerSkin::Shutdown(void)
+{
+	CTxdStore::RemoveTxdSlot(m_txdSlot);
+}
+
+RwTexture *
+CPlayerSkin::GetSkinTexture(const char *texName)
+{
+	RwTexture *tex;
+	RwRaster *raster;
+	int32 width, height, depth, format;
+
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(m_txdSlot);
+	tex = RwTextureRead(texName, NULL);
+	CTxdStore::PopCurrentTxd();
+	if (tex != nil) return tex;
+
+	if (strcmp(DEFAULT_SKIN_NAME, texName) == 0)
+		sprintf(gString, "models\\generic\\player.bmp");
+	else
+		sprintf(gString, "skins\\%s.bmp", texName);
+
+	if (RwImage *image = RtBMPImageRead(gString)) {
+		RwImageFindRasterFormat(image, rwRASTERTYPETEXTURE, &width, &height, &depth, &format);
+		raster = RwRasterCreate(width, height, depth, format);
+		RwRasterSetFromImage(raster, image);
+
+		tex = RwTextureCreate(raster);
+		RwTextureSetName(tex, texName);
+#ifdef FIX_BUGS
+		RwTextureSetFilterMode(tex, rwFILTERLINEAR); // filtering bugfix from VC
+#endif
+		RwTexDictionaryAddTexture(CTxdStore::GetSlot(m_txdSlot)->texDict, tex);
+
+		RwImageDestroy(image);
+	}
+	return tex;
+}
+
+void
+CPlayerSkin::BeginFrontendSkinEdit(void)
+{
+	LoadPlayerDff();
+	RpClumpForAllAtomics(gpPlayerClump, CClumpModelInfo::SetAtomicRendererCB, (void*)CVisibilityPlugins::RenderPlayerCB);
+	CWorld::Players[0].LoadPlayerSkin();
+	gOldFov = CDraw::GetFOV();
+	CDraw::SetFOV(30.0f);
+}
+
+void
+CPlayerSkin::EndFrontendSkinEdit(void)
+{
+	RpClumpDestroy(gpPlayerClump);
+	gpPlayerClump = NULL;
+	CDraw::SetFOV(gOldFov);
+}
+
+void
+CPlayerSkin::RenderFrontendSkinEdit(void)
+{
+	static float rotation = 0.0f;
+	RwRGBAReal AmbientColor = { 0.65f, 0.65f, 0.65f, 1.0f };
+	const RwV3d pos = { 1.35f, 0.35f, 7.725f };
+	const RwV3d axis1 = { 1.0f, 0.0f, 0.0f };
+	const RwV3d axis2 = { 0.0f, 0.0f, 1.0f };
+	static uint32 LastFlash = 0;
+
+	RwFrame *frame = RpClumpGetFrame(gpPlayerClump);
+
+	if (CTimer::GetTimeInMillisecondsPauseMode() - LastFlash > 7) {
+		rotation += 2.0f;
+		if (rotation > 360.0f)
+			rotation -= 360.0f;
+		LastFlash = CTimer::GetTimeInMillisecondsPauseMode();
+	}
+	RwFrameTransform(frame, RwFrameGetMatrix(RwCameraGetFrame(Scene.camera)), rwCOMBINEREPLACE);
+	RwFrameTranslate(frame, &pos, rwCOMBINEPRECONCAT);
+	RwFrameRotate(frame, &axis1, -90.0f, rwCOMBINEPRECONCAT);
+	RwFrameRotate(frame, &axis2, rotation, rwCOMBINEPRECONCAT);
+	RwFrameUpdateObjects(frame);
+	SetAmbientColours(&AmbientColor);
+	RpClumpRender(gpPlayerClump);
+}
diff --git a/src/renderer/PlayerSkin.h b/src/renderer/PlayerSkin.h
new file mode 100644
index 00000000..e0214ce0
--- /dev/null
+++ b/src/renderer/PlayerSkin.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#define DEFAULT_SKIN_NAME "$$\"\""
+
+class CPlayerSkin
+{
+	static int m_txdSlot;
+public:
+	static void Initialise();
+	static void Shutdown();
+	static RwTexture *GetSkinTexture(const char *texName);
+	static void BeginFrontendSkinEdit();
+	static void EndFrontendSkinEdit();
+	static void RenderFrontendSkinEdit();
+};
\ No newline at end of file
diff --git a/src/renderer/PointLights.cpp b/src/renderer/PointLights.cpp
new file mode 100644
index 00000000..84ac4ab2
--- /dev/null
+++ b/src/renderer/PointLights.cpp
@@ -0,0 +1,289 @@
+#include "common.h"
+
+#include "main.h"
+#include "Lights.h"
+#include "Camera.h"
+#include "Weather.h"
+#include "World.h"
+#include "Collision.h"
+#include "Sprite.h"
+#include "Timer.h"
+#include "PointLights.h"
+
+int16 CPointLights::NumLights;
+CRegisteredPointLight CPointLights::aLights[NUMPOINTLIGHTS];
+
+void
+CPointLights::InitPerFrame(void)
+{
+	NumLights = 0;
+}
+
+#define MAX_DIST 22.0f
+
+void
+CPointLights::AddLight(uint8 type, CVector coors, CVector dir, float radius, float red, float green, float blue, uint8 fogType, bool castExtraShadows)
+{
+	CVector dist;
+	float distance;
+
+	// The check is done in some weird way in the game
+	// we're doing it a bit better here
+	if(NumLights >= NUMPOINTLIGHTS)
+		return;
+
+	dist = coors - TheCamera.GetPosition();
+	if(Abs(dist.x) < MAX_DIST && Abs(dist.y) < MAX_DIST){
+		distance = dist.Magnitude();
+		if(distance < MAX_DIST){
+			aLights[NumLights].type = type;
+			aLights[NumLights].fogType = fogType;
+			aLights[NumLights].coors = coors;
+			aLights[NumLights].dir = dir;
+			aLights[NumLights].radius = radius;
+			aLights[NumLights].castExtraShadows = castExtraShadows;
+			if(distance < MAX_DIST*0.75f){
+				aLights[NumLights].red = red;
+				aLights[NumLights].green = green;
+				aLights[NumLights].blue = blue;
+			}else{
+				float fade = 1.0f - (distance/MAX_DIST - 0.75f)*4.0f;
+				aLights[NumLights].red = red * fade;
+				aLights[NumLights].green = green * fade;
+				aLights[NumLights].blue = blue * fade;
+			}
+			NumLights++;
+		}
+	}
+}
+
+float
+CPointLights::GenerateLightsAffectingObject(Const CVector *objCoors)
+{
+	int i;
+	float ret;
+	CVector dist;
+	float radius, distance;
+
+	ret = 1.0f;
+	for(i = 0; i < NumLights; i++){
+		if(aLights[i].type == LIGHT_FOGONLY || aLights[i].type == LIGHT_FOGONLY_ALWAYS)
+			continue;
+
+		// same weird distance calculation. simplified here
+		dist = aLights[i].coors - *objCoors;
+		radius = aLights[i].radius;
+		if(Abs(dist.x) < radius &&
+		   Abs(dist.y) < radius &&
+		   Abs(dist.z) < radius){
+
+			distance = dist.Magnitude();
+			if(distance < radius){
+
+				float distNorm = distance/radius;
+				if(aLights[i].type == LIGHT_DARKEN){
+					// darken the object the closer it is
+					ret *= distNorm;
+				}else{
+					float intensity;
+					// distance fade
+					if(distNorm < 0.5f)
+						intensity = 1.0f;
+					else
+						intensity = 1.0f - (distNorm - 0.5f)/(1.0f - 0.5f);
+
+					if(distance != 0.0f){
+						CVector dir = dist / distance;
+
+						if(aLights[i].type == LIGHT_DIRECTIONAL){
+							float dot = -DotProduct(dir, aLights[i].dir);
+							intensity *= Max((dot-0.5f)*2.0f, 0.0f);
+						}
+
+						if(intensity > 0.0f)
+							AddAnExtraDirectionalLight(Scene.world,
+								dir.x, dir.y, dir.z,
+								aLights[i].red*intensity, aLights[i].green*intensity, aLights[i].blue*intensity);
+					}
+				}
+			}
+		}
+	}
+
+	return ret;
+}
+
+extern RwRaster *gpPointlightRaster;
+
+void
+CPointLights::RemoveLightsAffectingObject(void)
+{
+	RemoveExtraDirectionalLights(Scene.world);
+}
+
+// for directional fog
+#define FOG_AREA_LENGTH 12.0f
+#define FOG_AREA_WIDTH 5.0f
+// for pointlight fog
+#define FOG_AREA_RADIUS 9.0f
+
+float FogSizes[8] = { 1.3f, 2.0f, 1.7f, 2.0f, 1.4f, 2.1f, 1.5f, 2.3f };
+
+void
+CPointLights::RenderFogEffect(void)
+{
+	int i;
+	float fogginess;
+	CColPoint point;
+	CEntity *entity;
+	float xmin, ymin;
+	float xmax, ymax;
+	int16 xi, yi;
+	CVector spriteCoors;
+	float spritew, spriteh;
+
+	PUSH_RENDERGROUP("CPointLights::RenderFogEffect");
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, gpPointlightRaster);
+
+	for(i = 0; i < NumLights; i++){
+		if(aLights[i].fogType != FOG_NORMAL && aLights[i].fogType != FOG_ALWAYS)
+			continue;
+
+		fogginess = aLights[i].fogType == FOG_NORMAL ? CWeather::Foggyness : 1.0f;
+		if(fogginess == 0.0f)
+			continue;
+
+		if(aLights[i].type == LIGHT_DIRECTIONAL){
+
+			// TODO: test this. haven't found directional fog so far
+
+			float coors2X = aLights[i].coors.x + FOG_AREA_LENGTH*aLights[i].dir.x;
+			float coors2Y = aLights[i].coors.y + FOG_AREA_LENGTH*aLights[i].dir.y;
+
+			if(coors2X < aLights[i].coors.x){
+				xmin = coors2X;
+				xmax = aLights[i].coors.x;
+			}else{
+				xmax = coors2X;
+				xmin = aLights[i].coors.x;
+			}
+			if(coors2Y < aLights[i].coors.y){
+				ymin = coors2Y;
+				ymax = aLights[i].coors.y;
+			}else{
+				ymax = coors2Y;
+				ymin = aLights[i].coors.y;
+			}
+
+			xmin -= 5.0f;
+			ymin -= 5.0f;
+			xmax += 5.0f;
+			ymax += 5.0f;
+
+			for(xi = (int16)xmin - (int16)xmin % 4; xi <= (int16)xmax + 4; xi += 4){
+				for(yi = (int16)ymin - (int16)ymin % 4; yi <= (int16)ymax + 4; yi += 4){
+					// Some kind of pseudo random number?
+					int r = (xi ^ yi)>>2 & 0xF;
+					if((r & 1) == 0)
+						continue;
+
+					// Check if fog effect is close enough to directional line in x and y
+					float dx = xi - aLights[i].coors.x;
+					float dy = yi - aLights[i].coors.y;
+					float dot = dx*aLights[i].dir.x + dy*aLights[i].dir.y;
+					float distsq = sq(dx) + sq(dy);
+					float linedistsq = distsq - sq(dot);
+					if(dot > 0.0f && dot < FOG_AREA_LENGTH && linedistsq < sq(FOG_AREA_WIDTH)){
+						CVector fogcoors(xi, yi, aLights[i].coors.z + 10.0f);
+						if(CWorld::ProcessVerticalLine(fogcoors, fogcoors.z - 20.0f,
+								point, entity, true, false, false, false, true, false, nil)){
+							// Now same check again in xyz
+							fogcoors.z = point.point.z + 1.3f;
+							// actually we don't have to recalculate x and y, but the game does it that way
+							dx = xi - aLights[i].coors.x;
+							dy = yi - aLights[i].coors.y;
+							float dz = fogcoors.z - aLights[i].coors.z;
+							dot = dx*aLights[i].dir.x + dy*aLights[i].dir.y + dz*aLights[i].dir.z;
+							distsq = sq(dx) + sq(dy) + sq(dz);
+							linedistsq = distsq - sq(dot);
+							if(dot > 0.0f && dot < FOG_AREA_LENGTH && linedistsq < sq(FOG_AREA_WIDTH)){
+								float intensity = 158.0f * fogginess;
+								// more intensity the smaller the angle
+								intensity *= dot/Sqrt(distsq);
+								// more intensity the closer to light source
+								intensity *= 1.0f - sq(dot/FOG_AREA_LENGTH);
+								// more intensity the closer to line
+								intensity *= 1.0f - sq(Sqrt(linedistsq) / FOG_AREA_WIDTH);
+
+								if(CSprite::CalcScreenCoors(fogcoors, &spriteCoors, &spritew, &spriteh, true)){
+									float rotation = (CTimer::GetTimeInMilliseconds()&0x1FFF) * 2*3.14f / 0x2000;
+									float size = FogSizes[r>>1];
+									CSprite::RenderOneXLUSprite_Rotate_Aspect(spriteCoors.x, spriteCoors.y, spriteCoors.z,
+										spritew * size, spriteh * size,
+										aLights[i].red * intensity, aLights[i].green * intensity, aLights[i].blue * intensity,
+										intensity, 1/spriteCoors.z, rotation, 255);
+								}
+							}
+						}
+					}
+				}
+			}
+
+		}else if(aLights[i].type == LIGHT_POINT || aLights[i].type == LIGHT_FOGONLY || aLights[i].type == LIGHT_FOGONLY_ALWAYS){
+			if(CWorld::ProcessVerticalLine(aLights[i].coors, aLights[i].coors.z - 20.0f,
+					point, entity, true, false, false, false, true, false, nil)){
+
+				xmin = aLights[i].coors.x - FOG_AREA_RADIUS;
+				ymin = aLights[i].coors.y - FOG_AREA_RADIUS;
+				xmax = aLights[i].coors.x + FOG_AREA_RADIUS;
+				ymax = aLights[i].coors.y + FOG_AREA_RADIUS;
+
+				for(xi = (int16)xmin - (int16)xmin % 2; xi <= (int16)xmax + 2; xi += 2){
+					for(yi = (int16)ymin - (int16)ymin % 2; yi <= (int16)ymax + 2; yi += 2){
+						// Some kind of pseudo random number?
+						int r = (xi ^ yi)>>1 & 0xF;
+						if((r & 1) == 0)
+							continue;
+
+						float dx = xi - aLights[i].coors.x;
+						float dy = yi - aLights[i].coors.y;
+						float lightdist = Sqrt(sq(dx) + sq(dy));
+						if(lightdist < FOG_AREA_RADIUS){
+							dx = xi - TheCamera.GetPosition().x;
+							dy = yi - TheCamera.GetPosition().y;
+							float camdist = Sqrt(sq(dx) + sq(dy));
+							if(camdist < MAX_DIST){
+								float intensity;
+								// distance fade
+								if(camdist < MAX_DIST/2)
+									intensity = 1.0f;
+								else
+									intensity = 1.0f - (camdist - MAX_DIST/2) / (MAX_DIST/2);
+								intensity *= 132.0f * fogginess;
+								// more intensity the closer to light source
+								intensity *= 1.0f - sq(lightdist / FOG_AREA_RADIUS);
+
+								CVector fogcoors(xi, yi, point.point.z + 1.6f);
+								if(CSprite::CalcScreenCoors(fogcoors, &spriteCoors, &spritew, &spriteh, true)){
+									float rotation = (CTimer::GetTimeInMilliseconds()&0x3FFF) * 2*3.14f / 0x4000;
+									float size = FogSizes[r>>1];
+									CSprite::RenderOneXLUSprite_Rotate_Aspect(spriteCoors.x, spriteCoors.y, spriteCoors.z,
+										spritew * size, spriteh * size,
+										aLights[i].red * intensity, aLights[i].green * intensity, aLights[i].blue * intensity,
+										intensity, 1/spriteCoors.z, rotation, 255);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	POP_RENDERGROUP();
+}
diff --git a/src/renderer/PointLights.h b/src/renderer/PointLights.h
new file mode 100644
index 00000000..9e94328f
--- /dev/null
+++ b/src/renderer/PointLights.h
@@ -0,0 +1,45 @@
+#pragma once
+
+class CRegisteredPointLight
+{
+public:
+	CVector coors;
+	CVector dir;
+	float radius;
+	float red;
+	float green;
+	float blue;
+	int8 type;
+	int8 fogType;
+	bool castExtraShadows;
+};
+VALIDATE_SIZE(CRegisteredPointLight, 0x2C);
+
+class CPointLights
+{
+public:
+	static int16 NumLights;
+	static CRegisteredPointLight aLights[NUMPOINTLIGHTS];
+
+	enum {
+		LIGHT_POINT,
+		LIGHT_DIRECTIONAL,
+		LIGHT_DARKEN,	// no effects at all
+		// these have only fog, otherwise no difference?
+		// only used by CEntity::ProcessLightsForEntity it seems
+		// and there used together with fog type
+		LIGHT_FOGONLY_ALWAYS,
+		LIGHT_FOGONLY,
+	};
+	enum {
+		FOG_NONE,
+		FOG_NORMAL,	// taken from Foggyness
+		FOG_ALWAYS
+	};
+
+	static void InitPerFrame(void);
+	static void AddLight(uint8 type, CVector coors, CVector dir, float radius, float red, float green, float blue, uint8 fogType, bool castExtraShadows);
+	static float GenerateLightsAffectingObject(Const CVector *objCoors);
+	static void RemoveLightsAffectingObject(void);
+	static void RenderFogEffect(void);
+};
diff --git a/src/renderer/RenderBuffer.cpp b/src/renderer/RenderBuffer.cpp
new file mode 100644
index 00000000..6120dfe2
--- /dev/null
+++ b/src/renderer/RenderBuffer.cpp
@@ -0,0 +1,52 @@
+#include "common.h"
+
+#include "RenderBuffer.h"
+
+int32 TempBufferVerticesStored;
+int32 TempBufferIndicesStored;
+
+RwIm3DVertex TempBufferRenderVertices[TEMPBUFFERVERTSIZE];
+RwImVertexIndex TempBufferRenderIndexList[TEMPBUFFERINDEXSIZE];
+
+int RenderBuffer::VerticesToBeStored;
+int RenderBuffer::IndicesToBeStored;
+
+void
+RenderBuffer::ClearRenderBuffer(void)
+{
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+}
+
+void
+RenderBuffer::StartStoring(int numIndices, int numVertices, RwImVertexIndex **indexStart, RwIm3DVertex **vertexStart)
+{
+	if(TempBufferIndicesStored + numIndices >= TEMPBUFFERINDEXSIZE)
+		RenderStuffInBuffer();
+	if(TempBufferVerticesStored + numVertices >= TEMPBUFFERVERTSIZE)
+		RenderStuffInBuffer();
+        *indexStart = &TempBufferRenderIndexList[TempBufferIndicesStored];
+        *vertexStart = &TempBufferRenderVertices[TempBufferVerticesStored];
+        IndicesToBeStored = numIndices;
+        VerticesToBeStored = numVertices;
+}
+
+void
+RenderBuffer::StopStoring(void)
+{
+	int i;
+	for(i = TempBufferIndicesStored; i < TempBufferIndicesStored+IndicesToBeStored; i++)
+		TempBufferRenderIndexList[i] += TempBufferVerticesStored;
+	TempBufferIndicesStored += IndicesToBeStored;
+	TempBufferVerticesStored += VerticesToBeStored;
+}
+
+void
+RenderBuffer::RenderStuffInBuffer(void)
+{
+	if(TempBufferVerticesStored && RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV)){
+		RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+		RwIm3DEnd();
+	}
+	ClearRenderBuffer();
+}
diff --git a/src/renderer/RenderBuffer.h b/src/renderer/RenderBuffer.h
new file mode 100644
index 00000000..485d24e3
--- /dev/null
+++ b/src/renderer/RenderBuffer.h
@@ -0,0 +1,18 @@
+class RenderBuffer
+{
+public:
+	static int VerticesToBeStored;
+	static int IndicesToBeStored;
+	static void ClearRenderBuffer(void);
+	static void StartStoring(int numIndices, int numVertices, RwImVertexIndex **indexStart, RwIm3DVertex **vertexStart);
+	static void StopStoring(void);
+	static void RenderStuffInBuffer(void);
+};
+
+#define TEMPBUFFERVERTSIZE 256
+#define TEMPBUFFERINDEXSIZE 1024
+
+extern int32 TempBufferVerticesStored;
+extern int32 TempBufferIndicesStored;
+extern RwIm3DVertex TempBufferRenderVertices[TEMPBUFFERVERTSIZE];
+extern RwImVertexIndex TempBufferRenderIndexList[TEMPBUFFERINDEXSIZE];
\ No newline at end of file
diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp
new file mode 100644
index 00000000..1c0bd445
--- /dev/null
+++ b/src/renderer/Renderer.cpp
@@ -0,0 +1,1838 @@
+#define WITHD3D
+#include "common.h"
+
+#include "main.h"
+#include "Lights.h"
+#include "ModelInfo.h"
+#include "Treadable.h"
+#include "Ped.h"
+#include "Vehicle.h"
+#include "Boat.h"
+#include "Heli.h"
+#include "Object.h"
+#include "PathFind.h"
+#include "Collision.h"
+#include "VisibilityPlugins.h"
+#include "Clock.h"
+#include "World.h"
+#include "Camera.h"
+#include "ModelIndices.h"
+#include "Streaming.h"
+#include "Shadows.h"
+#include "PointLights.h"
+#include "Renderer.h"
+#include "Frontend.h"
+#include "custompipes.h"
+#include "Debug.h"
+
+bool gbShowPedRoadGroups;
+bool gbShowCarRoadGroups;
+bool gbShowCollisionPolys;
+bool gbShowCollisionLines;
+bool gbShowCullZoneDebugStuff;
+bool gbDisableZoneCull;	// not original
+bool gbBigWhiteDebugLightSwitchedOn;
+
+bool gbDontRenderBuildings;
+bool gbDontRenderBigBuildings;
+bool gbDontRenderPeds;
+bool gbDontRenderObjects;
+bool gbDontRenderVehicles;
+
+int32 EntitiesRendered;
+int32 EntitiesNotRendered;
+int32 RenderedBigBuildings;
+int32 RenderedBuildings;
+int32 RenderedCars;
+int32 RenderedPeds;
+int32 RenderedObjects;
+int32 RenderedDummies;
+int32 TestedBigBuildings;
+int32 TestedBuildings;
+int32 TestedCars;
+int32 TestedPeds;
+int32 TestedObjects;
+int32 TestedDummies;
+
+// unused
+int16 TestCloseThings;
+int16 TestBigThings;
+
+struct EntityInfo
+{
+	CEntity *ent;
+	float sort;
+};
+
+CLinkList<EntityInfo> gSortedVehiclesAndPeds;
+
+int32 CRenderer::ms_nNoOfVisibleEntities;
+CEntity *CRenderer::ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
+CEntity *CRenderer::ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
+int32 CRenderer::ms_nNoOfInVisibleEntities;
+#ifdef NEW_RENDERER
+int32 CRenderer::ms_nNoOfVisibleVehicles;
+CEntity *CRenderer::ms_aVisibleVehiclePtrs[NUMVISIBLEENTITIES];
+int32 CRenderer::ms_nNoOfVisibleBuildings;
+CEntity *CRenderer::ms_aVisibleBuildingPtrs[NUMVISIBLEENTITIES];
+
+CLinkList<EntityInfo> gSortedBuildings;
+#endif
+
+CVector CRenderer::ms_vecCameraPosition;
+CVehicle *CRenderer::m_pFirstPersonVehicle;
+bool CRenderer::m_loadingPriority;
+float CRenderer::ms_lodDistScale = 1.2f;
+
+// unused
+BlockedRange CRenderer::aBlockedRanges[16];
+BlockedRange *CRenderer::pFullBlockedRanges;
+BlockedRange *CRenderer::pEmptyBlockedRanges;
+
+void
+CRenderer::Init(void)
+{
+	gSortedVehiclesAndPeds.Init(40);
+	SortBIGBuildings();
+#ifdef NEW_RENDERER
+	gSortedBuildings.Init(NUMVISIBLEENTITIES);
+#endif
+}
+
+void
+CRenderer::Shutdown(void)
+{
+	gSortedVehiclesAndPeds.Shutdown();
+#ifdef NEW_RENDERER
+	gSortedBuildings.Shutdown();
+#endif
+}
+
+void
+CRenderer::PreRender(void)
+{
+	int i;
+	CLink<CVisibilityPlugins::AlphaObjectInfo> *node;
+
+	for(i = 0; i < ms_nNoOfVisibleEntities; i++)
+		ms_aVisibleEntityPtrs[i]->PreRender();
+
+#ifdef NEW_RENDERER
+	if(gbNewRenderer){
+		for(i = 0; i < ms_nNoOfVisibleVehicles; i++)
+			ms_aVisibleVehiclePtrs[i]->PreRender();
+		// How is this done with cWorldStream?
+		//for(i = 0; i < ms_nNoOfVisibleBuildings; i++)
+		//	ms_aVisibleBuildingPtrs[i]->PreRender();
+		for(CLink<EntityInfo> *node = gSortedBuildings.head.next;
+		    node != &gSortedBuildings.tail;
+		    node = node->next)
+			((CEntity*)node->item.ent)->PreRender();
+		for(node = CVisibilityPlugins::m_alphaBuildingList.head.next;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.tail;
+		    node = node->next)
+			((CEntity*)node->item.entity)->PreRender();
+	}
+#endif
+
+	for (i = 0; i < ms_nNoOfInVisibleEntities; i++) {
+#ifdef SQUEEZE_PERFORMANCE
+		if (ms_aInVisibleEntityPtrs[i]->IsVehicle() && ((CVehicle*)ms_aInVisibleEntityPtrs[i])->IsHeli())
+#endif
+		ms_aInVisibleEntityPtrs[i]->PreRender();
+	}
+
+	for(node = CVisibilityPlugins::m_alphaEntityList.head.next;
+	    node != &CVisibilityPlugins::m_alphaEntityList.tail;
+	    node = node->next)
+		((CEntity*)node->item.entity)->PreRender();
+
+	CHeli::SpecialHeliPreRender();
+	CShadows::RenderExtraPlayerShadows();
+}
+
+void
+CRenderer::RenderOneRoad(CEntity *e)
+{
+	if(gbDontRenderBuildings)
+		return;
+	if(gbShowCollisionPolys)
+		CCollision::DrawColModel_Coloured(e->GetMatrix(), *CModelInfo::GetModelInfo(e->GetModelIndex())->GetColModel(), e->GetModelIndex());
+	else{
+#ifdef EXTENDED_PIPELINES
+		CustomPipes::AttachGlossPipe(e->GetAtomic());
+#endif
+		PUSH_RENDERGROUP(CModelInfo::GetModelInfo(e->GetModelIndex())->GetModelName());
+
+#ifdef EXTRA_MODEL_FLAGS
+	if(!e->IsBuilding() || CModelInfo::GetModelInfo(e->GetModelIndex())->RenderDoubleSided()){
+		BACKFACE_CULLING_OFF;
+		e->Render();
+		BACKFACE_CULLING_ON;
+	}else
+#endif
+		e->Render();
+
+		POP_RENDERGROUP();
+	}
+}
+
+void
+CRenderer::RenderOneNonRoad(CEntity *e)
+{
+	CPed *ped;
+	CVehicle *veh;
+	int i;
+	bool resetLights;
+
+#ifndef MASTER
+	if(gbShowCollisionPolys){
+		if(!e->IsVehicle()){
+			CCollision::DrawColModel_Coloured(e->GetMatrix(), *CModelInfo::GetModelInfo(e->GetModelIndex())->GetColModel(), e->GetModelIndex());
+			return;
+		}
+	}else if(e->IsBuilding()){
+		if(e->bIsBIGBuilding){
+			if(gbDontRenderBigBuildings)
+				return;
+		}else{
+			if(gbDontRenderBuildings)
+				return;
+		}
+	}else
+#endif
+	if(e->IsPed()){
+#ifndef MASTER
+		if(gbDontRenderPeds)
+			return;
+#endif
+		ped = (CPed*)e;
+		if(ped->m_nPedState == PED_DRIVING)
+			return;
+	}
+#ifndef MASTER
+	else if(e->IsObject() || e->IsDummy()){
+		if(gbDontRenderObjects)
+			return;
+	}else if(e->IsVehicle()){
+		// re3 addition
+		if(gbDontRenderVehicles)
+			return;
+	}
+#endif
+
+	PUSH_RENDERGROUP(CModelInfo::GetModelInfo(e->GetModelIndex())->GetModelName());
+
+	resetLights = e->SetupLighting();
+
+	if(e->IsVehicle())
+		CVisibilityPlugins::InitAlphaAtomicList();
+
+	// Render Peds in vehicle before vehicle itself
+	if(e->IsVehicle()){
+		veh = (CVehicle*)e;
+		if(veh->pDriver && veh->pDriver->m_nPedState == PED_DRIVING)
+			veh->pDriver->Render();
+		for(i = 0; i < 8; i++)
+			if(veh->pPassengers[i] && veh->pPassengers[i]->m_nPedState == PED_DRIVING)
+				veh->pPassengers[i]->Render();
+		BACKFACE_CULLING_OFF;
+	}
+#ifdef EXTRA_MODEL_FLAGS
+	if(!e->IsBuilding() || CModelInfo::GetModelInfo(e->GetModelIndex())->RenderDoubleSided()){
+		BACKFACE_CULLING_OFF;
+		e->Render();
+		BACKFACE_CULLING_ON;
+	}else
+#endif
+	e->Render();
+
+	if(e->IsVehicle()){
+		BACKFACE_CULLING_OFF;
+		e->bImBeingRendered = true;
+		CVisibilityPlugins::RenderAlphaAtomics();
+		e->bImBeingRendered = false;
+		BACKFACE_CULLING_ON;
+	}
+
+	e->RemoveLighting(resetLights);
+
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderFirstPersonVehicle(void)
+{
+	if(m_pFirstPersonVehicle == nil)
+		return;
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RenderOneNonRoad(m_pFirstPersonVehicle);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+}
+
+inline bool IsRoad(CEntity *e) { return e->IsBuilding() && ((CBuilding*)e)->GetIsATreadable(); }
+
+void
+CRenderer::RenderRoads(void)
+{
+	int i;
+	CTreadable *t;
+
+	PUSH_RENDERGROUP("CRenderer::RenderRoads");
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	BACKFACE_CULLING_ON;
+	DeActivateDirectional();
+	SetAmbientColours();
+
+	for(i = 0; i < ms_nNoOfVisibleEntities; i++){
+		t = (CTreadable*)ms_aVisibleEntityPtrs[i];
+		if(IsRoad(t)){
+#ifndef MASTER
+			if(gbShowCarRoadGroups || gbShowPedRoadGroups){
+				int ind = 0;
+				if(gbShowCarRoadGroups)
+					ind += ThePaths.m_pathNodes[t->m_nodeIndices[PATH_CAR][0]].group;
+				if(gbShowPedRoadGroups)
+					ind += ThePaths.m_pathNodes[t->m_nodeIndices[PATH_PED][0]].group;
+				SetAmbientColoursToIndicateRoadGroup(ind);
+			}
+#endif
+			RenderOneRoad(t);
+#ifndef MASTER
+			if(gbShowCarRoadGroups || gbShowPedRoadGroups)
+				ReSetAmbientAndDirectionalColours();
+#endif
+		}
+	}
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderEverythingBarRoads(void)
+{
+	int i;
+	CEntity *e;
+	CVector dist;
+	EntityInfo ei;
+
+	PUSH_RENDERGROUP("CRenderer::RenderEverythingBarRoads");
+	BACKFACE_CULLING_ON;
+	gSortedVehiclesAndPeds.Clear();
+
+	for(i = 0; i < ms_nNoOfVisibleEntities; i++){
+		e = ms_aVisibleEntityPtrs[i];
+
+		if(IsRoad(e))
+			continue;
+
+#ifdef EXTENDED_PIPELINES
+		if(CustomPipes::bRenderingEnvMap && (e->IsPed() || e->IsVehicle()))
+			continue;
+#endif
+
+		if(e->IsVehicle() ||
+		   e->IsPed() && CVisibilityPlugins::GetClumpAlpha((RpClump*)e->m_rwObject) != 255){
+			if(e->IsVehicle() && ((CVehicle*)e)->IsBoat()){
+				ei.ent = e;
+				dist = ms_vecCameraPosition - e->GetPosition();
+				ei.sort = dist.MagnitudeSqr();
+				gSortedVehiclesAndPeds.InsertSorted(ei);
+			}else{
+				dist = ms_vecCameraPosition - e->GetPosition();
+				if(!CVisibilityPlugins::InsertEntityIntoSortedList(e, dist.Magnitude())){
+					printf("Ran out of space in alpha entity list");
+					RenderOneNonRoad(e);
+				}
+			}
+		}else
+			RenderOneNonRoad(e);
+	}
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderVehiclesButNotBoats(void)
+{
+	// This function doesn't do anything
+	// because only boats are inserted into the list
+	CLink<EntityInfo> *node;
+
+	for(node = gSortedVehiclesAndPeds.tail.prev;
+	    node != &gSortedVehiclesAndPeds.head;
+	    node = node->prev){
+		// only boats in this list
+		CVehicle *v = (CVehicle*)node->item.ent;
+		if(!v->IsBoat())
+			RenderOneNonRoad(v);
+	}
+}
+
+void
+CRenderer::RenderBoats(void)
+{
+	CLink<EntityInfo> *node;
+
+	PUSH_RENDERGROUP("CRenderer::RenderBoats");
+	BACKFACE_CULLING_ON;
+
+	for(node = gSortedVehiclesAndPeds.tail.prev;
+	    node != &gSortedVehiclesAndPeds.head;
+	    node = node->prev){
+		// only boats in this list
+		CVehicle *v = (CVehicle*)node->item.ent;
+		if(v->IsBoat())
+			RenderOneNonRoad(v);
+	}
+	POP_RENDERGROUP();
+}
+
+#ifdef NEW_RENDERER
+#ifndef LIBRW
+#error "Need librw for EXTENDED_PIPELINES"
+#endif
+#include "WaterLevel.h"
+
+enum {
+	// blend passes
+	PASS_NOZ,	// no z-write
+	PASS_ADD,	// additive
+	PASS_BLEND	// normal blend
+};
+
+static RwRGBAReal black;
+
+static void
+SetStencilState(int state)
+{
+	switch(state){
+	// disable stencil
+	case 0:
+		rw::SetRenderState(rw::STENCILENABLE, FALSE);
+		break;
+	// test against stencil
+	case 1:
+		rw::SetRenderState(rw::STENCILENABLE, TRUE);
+		rw::SetRenderState(rw::STENCILFUNCTION, rw::STENCILNOTEQUAL);
+		rw::SetRenderState(rw::STENCILPASS, rw::STENCILKEEP);
+		rw::SetRenderState(rw::STENCILFAIL, rw::STENCILKEEP);
+		rw::SetRenderState(rw::STENCILZFAIL, rw::STENCILKEEP);
+		rw::SetRenderState(rw::STENCILFUNCTIONMASK, 0xFF);
+		rw::SetRenderState(rw::STENCILFUNCTIONREF, 0xFF);
+		break;
+	// write to stencil
+	case 2:
+		rw::SetRenderState(rw::STENCILENABLE, TRUE);
+		rw::SetRenderState(rw::STENCILFUNCTION, rw::STENCILALWAYS);
+		rw::SetRenderState(rw::STENCILPASS, rw::STENCILREPLACE);
+		rw::SetRenderState(rw::STENCILFUNCTIONREF, 0xFF);
+		break;
+	}
+}
+
+void
+CRenderer::RenderOneBuilding(CEntity *ent, float camdist)
+{
+	if(ent->m_rwObject == nil)
+		return;
+
+	ent->bImBeingRendered = true;	// TODO: this seems wrong, but do we even need it?
+
+	assert(RwObjectGetType(ent->m_rwObject) == rpATOMIC);
+	RpAtomic *atomic = (RpAtomic*)ent->m_rwObject;
+	CSimpleModelInfo *mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(ent->GetModelIndex());
+
+#ifdef EXTRA_MODEL_FLAGS
+	bool resetCull = false;
+	if(!ent->IsBuilding() || mi->RenderDoubleSided()){
+		resetCull = true;
+		BACKFACE_CULLING_OFF;
+	}
+#endif
+
+	int pass = PASS_BLEND;
+	if(mi->m_additive)	// very questionable
+		pass = PASS_ADD;
+	if(mi->m_noZwrite)
+		pass = PASS_NOZ;
+
+	if(ent->bDistanceFade){
+		RpAtomic *lodatm;
+		float fadefactor;
+		uint32 alpha;
+
+		lodatm = mi->GetAtomicFromDistance(camdist - FADE_DISTANCE);
+		fadefactor = (mi->GetLargestLodDistance() - (camdist - FADE_DISTANCE))/FADE_DISTANCE;
+		if(fadefactor > 1.0f)
+			fadefactor = 1.0f;
+		alpha = mi->m_alpha * fadefactor;
+
+		if(alpha == 255)
+			WorldRender::AtomicFirstPass(atomic, pass);
+		else{
+			// not quite sure what this is about, do we have to do that?
+			RpGeometry *geo = RpAtomicGetGeometry(lodatm);
+			if(geo != RpAtomicGetGeometry(atomic))
+				RpAtomicSetGeometry(atomic, geo, rpATOMICSAMEBOUNDINGSPHERE);
+			WorldRender::AtomicFullyTransparent(atomic, pass, alpha);
+		}
+	}else
+		WorldRender::AtomicFirstPass(atomic, pass);
+
+#ifdef EXTRA_MODEL_FLAGS
+	if(resetCull)
+		BACKFACE_CULLING_ON;
+#endif
+
+	ent->bImBeingRendered = false;	// TODO: this seems wrong, but do we even need it?
+}
+
+void
+CRenderer::RenderWorld(int pass)
+{
+	int i;
+	CEntity *e;
+	CLink<CVisibilityPlugins::AlphaObjectInfo> *node;
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	BACKFACE_CULLING_ON;
+	DeActivateDirectional();
+	SetAmbientColours();
+
+	// Temporary...have to figure out sorting better
+	switch(pass){
+	case 0:
+		// Roads
+		PUSH_RENDERGROUP("CRenderer::RenderWorld - Roads");
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+/*
+		for(i = 0; i < ms_nNoOfVisibleBuildings; i++){
+			e = ms_aVisibleBuildingPtrs[i];
+			if(e->bIsBIGBuilding || IsRoad(e))
+				RenderOneBuilding(e);
+		}
+*/
+		for(CLink<EntityInfo> *node = gSortedBuildings.tail.prev;
+		    node != &gSortedBuildings.head;
+		    node = node->prev){
+			e = node->item.ent;
+			if(e->bIsBIGBuilding || IsRoad(e))
+				RenderOneBuilding(e);
+		}
+		for(node = CVisibilityPlugins::m_alphaBuildingList.tail.prev;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.head;
+		    node = node->prev){
+			e = node->item.entity;
+			if(e->bIsBIGBuilding || IsRoad(e))
+				RenderOneBuilding(e, node->item.sort);
+		}
+
+		// KLUDGE for road puddles which have to be rendered at road-time
+		// only very temporary, there are more rendering issues
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		WorldRender::RenderBlendPass(PASS_BLEND);
+		WorldRender::numBlendInsts[PASS_BLEND] = 0;
+		POP_RENDERGROUP();
+		break;
+	case 1:
+		// Opaque
+		PUSH_RENDERGROUP("CRenderer::RenderWorld - Opaque");
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+/*
+		for(i = 0; i < ms_nNoOfVisibleBuildings; i++){
+			e = ms_aVisibleBuildingPtrs[i];
+			if(!(e->bIsBIGBuilding || IsRoad(e)))
+				RenderOneBuilding(e);
+		}
+*/
+		for(CLink<EntityInfo> *node = gSortedBuildings.tail.prev;
+		    node != &gSortedBuildings.head;
+		    node = node->prev){
+			e = node->item.ent;
+			if(!(e->bIsBIGBuilding || IsRoad(e)))
+				RenderOneBuilding(e);
+		}
+		for(node = CVisibilityPlugins::m_alphaBuildingList.tail.prev;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.head;
+		    node = node->prev){
+			e = node->item.entity;
+			if(!(e->bIsBIGBuilding || IsRoad(e)))
+				RenderOneBuilding(e, node->item.sort);
+		}
+		// Now we have iterated through all visible buildings (unsorted and sorted)
+		// and the transparency list is done.
+
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, FALSE);
+		WorldRender::RenderBlendPass(PASS_NOZ);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		POP_RENDERGROUP();
+		break;
+	case 2:
+		// Transparent
+		PUSH_RENDERGROUP("CRenderer::RenderWorld - Transparent");
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		WorldRender::RenderBlendPass(PASS_ADD);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		WorldRender::RenderBlendPass(PASS_BLEND);
+		POP_RENDERGROUP();
+		break;
+	}
+}
+
+void
+CRenderer::RenderPeds(void)
+{
+	int i;
+	CEntity *e;
+
+	PUSH_RENDERGROUP("CRenderer::RenderPeds");
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(e->IsPed())
+			RenderOneNonRoad(e);
+	}
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderVehicles(void)
+{
+	int i;
+	CEntity *e;
+	EntityInfo ei;
+	CLink<EntityInfo> *node;
+
+	PUSH_RENDERGROUP("CRenderer::RenderVehicles");
+	// not the real thing
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(!e->IsVehicle())
+			continue;
+//		if(PutIntoSortedVehicleList((CVehicle*)e))
+//			continue;	// boats handled elsewhere
+		ei.ent = e;
+		ei.sort = (ms_vecCameraPosition - e->GetPosition()).MagnitudeSqr();
+		gSortedVehiclesAndPeds.InsertSorted(ei);
+	}
+
+	for(node = gSortedVehiclesAndPeds.tail.prev;
+	    node != &gSortedVehiclesAndPeds.head;
+	    node = node->prev)
+		RenderOneNonRoad(node->item.ent);
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderWater(void)
+{
+	int i;
+	CEntity *e;
+
+	PUSH_RENDERGROUP("CRenderer::RenderWater");
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDZERO);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	SetStencilState(2);
+
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(e->IsVehicle() && ((CVehicle*)e)->IsBoat())
+			((CBoat*)e)->RenderWaterOutPolys();
+	}
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	SetStencilState(1);
+
+	CWaterLevel::RenderWater();
+
+	SetStencilState(0);
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::ClearForFrame(void)
+{
+	ms_nNoOfVisibleEntities = 0;
+	ms_nNoOfVisibleVehicles = 0;
+	ms_nNoOfVisibleBuildings = 0;
+	ms_nNoOfInVisibleEntities = 0;
+	gSortedVehiclesAndPeds.Clear();
+	gSortedBuildings.Clear();
+
+	WorldRender::numBlendInsts[PASS_NOZ] = 0;
+	WorldRender::numBlendInsts[PASS_ADD] = 0;
+	WorldRender::numBlendInsts[PASS_BLEND] = 0;
+}
+#endif
+
+void
+CRenderer::RenderFadingInEntities(void)
+{
+	PUSH_RENDERGROUP("CRenderer::RenderFadingInEntities");
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	BACKFACE_CULLING_ON;
+	DeActivateDirectional();
+	SetAmbientColours();
+	CVisibilityPlugins::RenderFadingEntities();
+	POP_RENDERGROUP();
+}
+
+void
+CRenderer::RenderCollisionLines(void)
+{
+	int i;
+
+	// game doesn't draw fading in entities
+	// this should probably be fixed
+	for(i = 0; i < ms_nNoOfVisibleEntities; i++){
+		CEntity *e = ms_aVisibleEntityPtrs[i];
+		if(Abs(e->GetPosition().x - ms_vecCameraPosition.x) < 100.0f &&
+		   Abs(e->GetPosition().y - ms_vecCameraPosition.y) < 100.0f)
+			CCollision::DrawColModel(e->GetMatrix(), *e->GetColModel());
+	}
+}
+
+// unused
+void
+CRenderer::RenderBlockBuildingLines(void)
+{
+	for(BlockedRange *br = pFullBlockedRanges; br; br = br->next)
+		printf("Blocked: %f %f\n", br->a, br->b);
+}
+
+enum Visbility
+{
+	VIS_INVISIBLE,
+	VIS_VISIBLE,
+	VIS_OFFSCREEN,
+	VIS_STREAMME
+};
+
+// Time Objects can be time culled if
+//   other == -1 || CModelInfo::GetModelInfo(other)->GetRwObject()
+// i.e. we have to draw even at the wrong time if
+//   other != -1 && CModelInfo::GetModelInfo(other)->GetRwObject() == nil
+
+#define OTHERUNAVAILABLE (other != -1 && CModelInfo::GetModelInfo(other)->GetRwObject() == nil)
+#define CANTIMECULL (!OTHERUNAVAILABLE)
+
+int32
+CRenderer::SetupEntityVisibility(CEntity *ent)
+{
+	CSimpleModelInfo *mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(ent->m_modelIndex);
+	CTimeModelInfo *ti;
+	int32 other;
+	float dist;
+
+	bool request = true;
+	if (mi->GetModelType() == MITYPE_TIME) {
+ 		ti = (CTimeModelInfo*)mi;
+		other = ti->GetOtherTimeModel();
+		if(CClock::GetIsTimeInRange(ti->GetTimeOn(), ti->GetTimeOff())){
+			// don't fade in, or between time objects
+			if(CANTIMECULL)
+				ti->m_alpha = 255;
+		}else{
+			// Hide if possible
+			if(CANTIMECULL)
+				return VIS_INVISIBLE;
+			// can't cull, so we'll try to draw this one, but don't request
+			// it since what we really want is the other one.
+			request = false;
+		}
+	}else{
+		if (mi->GetModelType() != MITYPE_SIMPLE) {
+			if(FindPlayerVehicle() == ent &&
+			   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON){
+				// Player's vehicle in first person mode
+				if(TheCamera.Cams[TheCamera.ActiveCam].DirectionWasLooking == LOOKING_FORWARD ||
+				   ent->GetModelIndex() == MI_RHINO ||
+				   ent->GetModelIndex() == MI_COACH ||
+				   TheCamera.m_bInATunnelAndABigVehicle){
+					ent->bNoBrightHeadLights = true;
+				}else{
+					m_pFirstPersonVehicle = (CVehicle*)ent;
+					ent->bNoBrightHeadLights = false;
+				}
+				return VIS_OFFSCREEN;
+			}
+			// All sorts of Clumps
+			if(ent->m_rwObject == nil || !ent->bIsVisible)
+				return VIS_INVISIBLE;
+			if(!ent->GetIsOnScreen())
+				return VIS_OFFSCREEN;
+			if(ent->bDrawLast){
+				dist = (ent->GetPosition() - ms_vecCameraPosition).Magnitude();
+				CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+				ent->bDistanceFade = false;
+				return VIS_INVISIBLE;
+			}
+			return VIS_VISIBLE;
+		}
+		if(ent->IsObject() &&
+		   ((CObject*)ent)->ObjectCreatedBy == TEMP_OBJECT){
+			if(ent->m_rwObject == nil || !ent->bIsVisible)
+				return VIS_INVISIBLE;
+			return ent->GetIsOnScreen() ? VIS_VISIBLE : VIS_OFFSCREEN;
+		}
+	}
+
+	// Simple ModelInfo
+
+	dist = (ent->GetPosition() - ms_vecCameraPosition).Magnitude();
+
+	// This can only happen with multi-atomic models (e.g. railtracks)
+	// but why do we bump up the distance? can only be fading...
+	if(LOD_DISTANCE + STREAM_DISTANCE < dist && dist < mi->GetLargestLodDistance())
+		dist = mi->GetLargestLodDistance();
+
+	if(ent->IsObject() && ent->bRenderDamaged)
+		mi->m_isDamaged = true;
+
+	RpAtomic *a = mi->GetAtomicFromDistance(dist);
+	if(a){
+		mi->m_isDamaged = false;
+		if(ent->m_rwObject == nil)
+			ent->CreateRwObject();
+		assert(ent->m_rwObject);
+		RpAtomic *rwobj = (RpAtomic*)ent->m_rwObject;
+		// Make sure our atomic uses the right geometry and not
+		// that of an atomic for another draw distance.
+		if(RpAtomicGetGeometry(a) != RpAtomicGetGeometry(rwobj))
+			RpAtomicSetGeometry(rwobj, RpAtomicGetGeometry(a), rpATOMICSAMEBOUNDINGSPHERE); // originally 5 (mistake?)
+		mi->IncreaseAlpha();
+		if(ent->m_rwObject == nil || !ent->bIsVisible)
+			return VIS_INVISIBLE;
+
+		if(!ent->GetIsOnScreen()){
+			mi->m_alpha = 255;
+			return VIS_OFFSCREEN;
+		}
+
+		if(mi->m_alpha != 255){
+			CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+			ent->bDistanceFade = true;
+			return VIS_INVISIBLE;
+		}
+
+		if(mi->m_drawLast || ent->bDrawLast){
+			CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+			ent->bDistanceFade = false;
+			return VIS_INVISIBLE;
+		}
+		return VIS_VISIBLE;
+	}
+
+	// Object is not loaded, figure out what to do
+
+	if(mi->m_noFade){
+		mi->m_isDamaged = false;
+		// request model
+		if(dist - STREAM_DISTANCE < mi->GetLargestLodDistance() && request)
+			return VIS_STREAMME;
+		return VIS_INVISIBLE;
+	}
+
+	// We might be fading
+
+	a = mi->GetAtomicFromDistance(dist - FADE_DISTANCE);
+	mi->m_isDamaged = false;
+	if(a == nil){
+		// request model
+		if(dist - FADE_DISTANCE - STREAM_DISTANCE < mi->GetLargestLodDistance() && request)
+			return VIS_STREAMME;
+		return VIS_INVISIBLE;
+	}
+
+	if(ent->m_rwObject == nil)
+		ent->CreateRwObject();
+	assert(ent->m_rwObject);
+	RpAtomic *rwobj = (RpAtomic*)ent->m_rwObject;
+	if(RpAtomicGetGeometry(a) != RpAtomicGetGeometry(rwobj))
+		RpAtomicSetGeometry(rwobj, RpAtomicGetGeometry(a), rpATOMICSAMEBOUNDINGSPHERE); // originally 5 (mistake?)
+	mi->IncreaseAlpha();
+	if(ent->m_rwObject == nil || !ent->bIsVisible)
+		return VIS_INVISIBLE;
+
+	if(!ent->GetIsOnScreen()){
+		mi->m_alpha = 255;
+		return VIS_OFFSCREEN;
+	}else{
+		CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+		ent->bDistanceFade = true;
+		return VIS_OFFSCREEN;	// Why this?
+	}
+}
+
+int32
+CRenderer::SetupBigBuildingVisibility(CEntity *ent)
+{
+	CSimpleModelInfo *mi = (CSimpleModelInfo *)CModelInfo::GetModelInfo(ent->GetModelIndex());
+	CTimeModelInfo *ti;
+	int32 other;
+
+	if (mi->GetModelType() == MITYPE_TIME) {
+ 		ti = (CTimeModelInfo*)mi;
+		other = ti->GetOtherTimeModel();
+		// Hide objects not in time range if possible
+		if(CANTIMECULL)
+			if(!CClock::GetIsTimeInRange(ti->GetTimeOn(), ti->GetTimeOff()))
+				return VIS_INVISIBLE;
+		// Draw like normal
+	} else if (mi->GetModelType() == MITYPE_VEHICLE)
+		return ent->IsVisible() ? VIS_VISIBLE : VIS_INVISIBLE;
+
+	float dist = (ms_vecCameraPosition-ent->GetPosition()).Magnitude();
+	CSimpleModelInfo *nonLOD = mi->GetRelatedModel();
+
+	// Find out whether to draw below near distance.
+	// This is only the case if there is a non-LOD which is either not
+	// loaded or not completely faded in yet.
+	if(dist < mi->GetNearDistance() && dist < LOD_DISTANCE + STREAM_DISTANCE){
+		// No non-LOD or non-LOD is completely visible.
+		if(nonLOD == nil ||
+		   nonLOD->GetRwObject() && nonLOD->m_alpha == 255)
+			return VIS_INVISIBLE;
+
+		// But if it is a time object, we'd rather draw the wrong
+		// non-LOD than the right LOD.
+		if (nonLOD->GetModelType() == MITYPE_TIME) {
+			ti = (CTimeModelInfo*)nonLOD;
+			other = ti->GetOtherTimeModel();
+			if(other != -1 && CModelInfo::GetModelInfo(other)->GetRwObject())
+				return VIS_INVISIBLE;
+		}
+	}
+
+	RpAtomic *a = mi->GetAtomicFromDistance(dist);
+	if(a){
+		if(ent->m_rwObject == nil)
+			ent->CreateRwObject();
+		assert(ent->m_rwObject);
+		RpAtomic *rwobj = (RpAtomic*)ent->m_rwObject;
+
+		// Make sure our atomic uses the right geometry and not
+		// that of an atomic for another draw distance.
+		if(RpAtomicGetGeometry(a) != RpAtomicGetGeometry(rwobj))
+			RpAtomicSetGeometry(rwobj, RpAtomicGetGeometry(a), rpATOMICSAMEBOUNDINGSPHERE); // originally 5 (mistake?)
+		if (!ent->IsVisible() || !ent->GetIsOnScreenComplex())
+			return VIS_INVISIBLE;
+		if(mi->m_drawLast){
+			CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+			ent->bDistanceFade = false;
+			return VIS_INVISIBLE;
+		}
+		return VIS_VISIBLE;
+	}
+
+	if(mi->m_noFade){
+		ent->DeleteRwObject();
+		return VIS_INVISIBLE;
+	}
+
+
+	// get faded atomic
+	a = mi->GetAtomicFromDistance(dist - FADE_DISTANCE);
+	if(a == nil){
+		ent->DeleteRwObject();
+		return VIS_INVISIBLE;
+	}
+
+	// Fade...
+	if(ent->m_rwObject == nil)
+		ent->CreateRwObject();
+	assert(ent->m_rwObject);
+	RpAtomic *rwobj = (RpAtomic*)ent->m_rwObject;
+	if(RpAtomicGetGeometry(a) != RpAtomicGetGeometry(rwobj))
+		RpAtomicSetGeometry(rwobj, RpAtomicGetGeometry(a), rpATOMICSAMEBOUNDINGSPHERE); // originally 5 (mistake?)
+	if (ent->IsVisible() && ent->GetIsOnScreenComplex())
+		CVisibilityPlugins::InsertEntityIntoSortedList(ent, dist);
+	return VIS_INVISIBLE;
+}
+
+void
+CRenderer::ConstructRenderList(void)
+{
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+{
+	ms_nNoOfVisibleEntities = 0;
+	ms_nNoOfInVisibleEntities = 0;
+}
+	ms_vecCameraPosition = TheCamera.GetPosition();
+
+	// unused
+	pFullBlockedRanges = nil;
+	pEmptyBlockedRanges = aBlockedRanges;
+	for(int i = 0; i < 16; i++){
+		aBlockedRanges[i].prev = &aBlockedRanges[i-1];
+		aBlockedRanges[i].next = &aBlockedRanges[i+1];
+	}
+	aBlockedRanges[0].prev = nil;
+	aBlockedRanges[15].next = nil;
+
+	// unused
+	TestCloseThings = 0;
+	TestBigThings = 0;
+
+	ScanWorld();
+}
+
+void
+LimitFrustumVector(CVector &vec1, const CVector &vec2, float l)
+{
+	float f;
+	f = (l - vec2.z) / (vec1.z - vec2.z);
+	vec1.x = f*(vec1.x - vec2.x) + vec2.x;
+	vec1.y = f*(vec1.y - vec2.y) + vec2.y;
+	vec1.z = f*(vec1.z - vec2.z) + vec2.z;
+}
+
+enum Corners
+{
+	CORNER_CAM = 0,
+	CORNER_FAR_TOPLEFT,
+	CORNER_FAR_TOPRIGHT,
+	CORNER_FAR_BOTRIGHT,
+	CORNER_FAR_BOTLEFT,
+	CORNER_LOD_LEFT,
+	CORNER_LOD_RIGHT,
+	CORNER_PRIO_LEFT,
+	CORNER_PRIO_RIGHT,
+};
+
+void
+CRenderer::ScanWorld(void)
+{
+	float f = RwCameraGetFarClipPlane(TheCamera.m_pRwCamera);
+	RwV2d vw = *RwCameraGetViewWindow(TheCamera.m_pRwCamera);
+	CVector vectors[9];
+	RwMatrix *cammatrix;
+	RwV2d poly[3];
+
+#ifndef MASTER
+	// missing in game but has to be done somewhere
+	EntitiesRendered = 0;
+	EntitiesNotRendered = 0;
+	RenderedBigBuildings = 0;
+	RenderedBuildings = 0;
+	RenderedCars = 0;
+	RenderedPeds = 0;
+	RenderedObjects = 0;
+	RenderedDummies = 0;
+	TestedBigBuildings = 0;
+	TestedBuildings = 0;
+	TestedCars = 0;
+	TestedPeds = 0;
+	TestedObjects = 0;
+	TestedDummies = 0;
+#endif
+
+	memset(vectors, 0, sizeof(vectors));
+	vectors[CORNER_FAR_TOPLEFT].x = -vw.x * f;
+	vectors[CORNER_FAR_TOPLEFT].y = vw.y * f;
+	vectors[CORNER_FAR_TOPLEFT].z = f;
+	vectors[CORNER_FAR_TOPRIGHT].x = vw.x * f;
+	vectors[CORNER_FAR_TOPRIGHT].y = vw.y * f;
+	vectors[CORNER_FAR_TOPRIGHT].z = f;
+	vectors[CORNER_FAR_BOTRIGHT].x = vw.x * f;
+	vectors[CORNER_FAR_BOTRIGHT].y = -vw.y * f;
+	vectors[CORNER_FAR_BOTRIGHT].z = f;
+	vectors[CORNER_FAR_BOTLEFT].x = -vw.x * f;
+	vectors[CORNER_FAR_BOTLEFT].y = -vw.y * f;
+	vectors[CORNER_FAR_BOTLEFT].z = f;
+
+	cammatrix = RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera));
+
+	m_pFirstPersonVehicle = nil;
+	CVisibilityPlugins::InitAlphaEntityList();
+	CWorld::AdvanceCurrentScanCode();
+
+	if(cammatrix->at.z > 0.0f){
+		// looking up, bottom corners are further away
+		vectors[CORNER_LOD_LEFT] = vectors[CORNER_FAR_BOTLEFT] * LOD_DISTANCE/f;
+		vectors[CORNER_LOD_RIGHT] = vectors[CORNER_FAR_BOTRIGHT] * LOD_DISTANCE/f;
+	}else{
+		// looking down, top corners are further away
+		vectors[CORNER_LOD_LEFT] = vectors[CORNER_FAR_TOPLEFT] * LOD_DISTANCE/f;
+		vectors[CORNER_LOD_RIGHT] = vectors[CORNER_FAR_TOPRIGHT] * LOD_DISTANCE/f;
+	}
+	vectors[CORNER_PRIO_LEFT].x = vectors[CORNER_LOD_LEFT].x * 0.2f;
+	vectors[CORNER_PRIO_LEFT].y = vectors[CORNER_LOD_LEFT].y * 0.2f;
+	vectors[CORNER_PRIO_LEFT].z = vectors[CORNER_LOD_LEFT].z;
+	vectors[CORNER_PRIO_RIGHT].x = vectors[CORNER_LOD_RIGHT].x * 0.2f;
+	vectors[CORNER_PRIO_RIGHT].y = vectors[CORNER_LOD_RIGHT].y * 0.2f;
+	vectors[CORNER_PRIO_RIGHT].z = vectors[CORNER_LOD_RIGHT].z;
+	RwV3dTransformPoints(vectors, vectors, 9, cammatrix);
+
+	m_loadingPriority = false;
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+#ifdef FIX_BUGS
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_GTACLASSIC ||
+#endif
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+		CRect rect;
+		int x1, x2, y1, y2;
+		LimitFrustumVector(vectors[CORNER_FAR_TOPLEFT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_TOPLEFT]);
+		LimitFrustumVector(vectors[CORNER_FAR_TOPRIGHT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_TOPRIGHT]);
+		LimitFrustumVector(vectors[CORNER_FAR_BOTRIGHT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_BOTRIGHT]);
+		LimitFrustumVector(vectors[CORNER_FAR_BOTLEFT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_BOTLEFT]);
+		x1 = CWorld::GetSectorIndexX(rect.left);
+		if(x1 < 0) x1 = 0;
+		x2 = CWorld::GetSectorIndexX(rect.right);
+		if(x2 >= NUMSECTORS_X-1) x2 = NUMSECTORS_X-1;
+		y1 = CWorld::GetSectorIndexY(rect.top);
+		if(y1 < 0) y1 = 0;
+		y2 = CWorld::GetSectorIndexY(rect.bottom);
+		if(y2 >= NUMSECTORS_Y-1) y2 = NUMSECTORS_Y-1;
+		for(; x1 <= x2; x1++)
+			for(int y = y1; y <= y2; y++)
+				ScanSectorList(CWorld::GetSector(x1, y)->m_lists);
+	}else{
+		CVehicle *train = FindPlayerTrain();
+		if(train && train->GetPosition().z < 0.0f){
+			poly[0].x = CWorld::GetSectorX(vectors[CORNER_CAM].x);
+			poly[0].y = CWorld::GetSectorY(vectors[CORNER_CAM].y);
+			poly[1].x = CWorld::GetSectorX(vectors[CORNER_LOD_LEFT].x);
+			poly[1].y = CWorld::GetSectorY(vectors[CORNER_LOD_LEFT].y);
+			poly[2].x = CWorld::GetSectorX(vectors[CORNER_LOD_RIGHT].x);
+			poly[2].y = CWorld::GetSectorY(vectors[CORNER_LOD_RIGHT].y);
+			ScanSectorPoly(poly, 3, ScanSectorList_Subway);
+		}else{
+			if(f > LOD_DISTANCE){
+				// priority
+				poly[0].x = CWorld::GetSectorX(vectors[CORNER_CAM].x);
+				poly[0].y = CWorld::GetSectorY(vectors[CORNER_CAM].y);
+				poly[1].x = CWorld::GetSectorX(vectors[CORNER_PRIO_LEFT].x);
+				poly[1].y = CWorld::GetSectorY(vectors[CORNER_PRIO_LEFT].y);
+				poly[2].x = CWorld::GetSectorX(vectors[CORNER_PRIO_RIGHT].x);
+				poly[2].y = CWorld::GetSectorY(vectors[CORNER_PRIO_RIGHT].y);
+				ScanSectorPoly(poly, 3, ScanSectorList_Priority);
+
+				// below LOD
+				poly[0].x = CWorld::GetSectorX(vectors[CORNER_CAM].x);
+				poly[0].y = CWorld::GetSectorY(vectors[CORNER_CAM].y);
+				poly[1].x = CWorld::GetSectorX(vectors[CORNER_LOD_LEFT].x);
+				poly[1].y = CWorld::GetSectorY(vectors[CORNER_LOD_LEFT].y);
+				poly[2].x = CWorld::GetSectorX(vectors[CORNER_LOD_RIGHT].x);
+				poly[2].y = CWorld::GetSectorY(vectors[CORNER_LOD_RIGHT].y);
+				ScanSectorPoly(poly, 3, ScanSectorList);
+			}else{
+				poly[0].x = CWorld::GetSectorX(vectors[CORNER_CAM].x);
+				poly[0].y = CWorld::GetSectorY(vectors[CORNER_CAM].y);
+				poly[1].x = CWorld::GetSectorX(vectors[CORNER_FAR_TOPLEFT].x);
+				poly[1].y = CWorld::GetSectorY(vectors[CORNER_FAR_TOPLEFT].y);
+				poly[2].x = CWorld::GetSectorX(vectors[CORNER_FAR_TOPRIGHT].x);
+				poly[2].y = CWorld::GetSectorY(vectors[CORNER_FAR_TOPRIGHT].y);
+				ScanSectorPoly(poly, 3, ScanSectorList);
+			}
+#ifdef NO_ISLAND_LOADING
+			if (CMenuManager::m_PrefsIslandLoading == CMenuManager::ISLAND_LOADING_HIGH) {
+				ScanBigBuildingList(CWorld::GetBigBuildingList(LEVEL_INDUSTRIAL));
+				ScanBigBuildingList(CWorld::GetBigBuildingList(LEVEL_COMMERCIAL));
+				ScanBigBuildingList(CWorld::GetBigBuildingList(LEVEL_SUBURBAN));
+			} else 
+#endif
+			{
+	#ifdef FIX_BUGS
+			if (CCollision::ms_collisionInMemory != LEVEL_GENERIC)
+	#endif
+				ScanBigBuildingList(CWorld::GetBigBuildingList(CCollision::ms_collisionInMemory));
+			}
+			ScanBigBuildingList(CWorld::GetBigBuildingList(LEVEL_GENERIC));
+		}
+	}
+
+#ifndef MASTER
+	if(gbShowCullZoneDebugStuff){
+		sprintf(gString, "Rejected: %d/%d.", EntitiesNotRendered, EntitiesNotRendered + EntitiesRendered);
+		CDebug::PrintAt(gString, 10, 10);
+		sprintf(gString, "Tested:BBuild:%d Build:%d Peds:%d Cars:%d Obj:%d Dummies:%d",
+			TestedBigBuildings, TestedBuildings, TestedPeds, TestedCars, TestedObjects, TestedDummies);
+		CDebug::PrintAt(gString, 10, 11);
+		sprintf(gString, "Rendered:BBuild:%d Build:%d Peds:%d Cars:%d Obj:%d Dummies:%d",
+			RenderedBigBuildings, RenderedBuildings, RenderedPeds, RenderedCars, RenderedObjects, RenderedDummies);
+		CDebug::PrintAt(gString, 10, 12);
+	}
+#endif
+}
+
+void
+CRenderer::RequestObjectsInFrustum(void)
+{
+	float f = RwCameraGetFarClipPlane(TheCamera.m_pRwCamera);
+	RwV2d vw = *RwCameraGetViewWindow(TheCamera.m_pRwCamera);
+	CVector vectors[9];
+	RwMatrix *cammatrix;
+	RwV2d poly[3];
+
+	memset(vectors, 0, sizeof(vectors));
+	vectors[CORNER_FAR_TOPLEFT].x = -vw.x * f;
+	vectors[CORNER_FAR_TOPLEFT].y = vw.y * f;
+	vectors[CORNER_FAR_TOPLEFT].z = f;
+	vectors[CORNER_FAR_TOPRIGHT].x = vw.x * f;
+	vectors[CORNER_FAR_TOPRIGHT].y = vw.y * f;
+	vectors[CORNER_FAR_TOPRIGHT].z = f;
+	vectors[CORNER_FAR_BOTRIGHT].x = vw.x * f;
+	vectors[CORNER_FAR_BOTRIGHT].y = -vw.y * f;
+	vectors[CORNER_FAR_BOTRIGHT].z = f;
+	vectors[CORNER_FAR_BOTLEFT].x = -vw.x * f;
+	vectors[CORNER_FAR_BOTLEFT].y = -vw.y * f;
+	vectors[CORNER_FAR_BOTLEFT].z = f;
+
+	cammatrix = RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera));
+
+	CWorld::AdvanceCurrentScanCode();
+
+	if(cammatrix->at.z > 0.0f){
+		// looking up, bottom corners are further away
+		vectors[CORNER_LOD_LEFT] = vectors[CORNER_FAR_BOTLEFT] * LOD_DISTANCE/f;
+		vectors[CORNER_LOD_RIGHT] = vectors[CORNER_FAR_BOTRIGHT] * LOD_DISTANCE/f;
+	}else{
+		// looking down, top corners are further away
+		vectors[CORNER_LOD_LEFT] = vectors[CORNER_FAR_TOPLEFT] * LOD_DISTANCE/f;
+		vectors[CORNER_LOD_RIGHT] = vectors[CORNER_FAR_TOPRIGHT] * LOD_DISTANCE/f;
+	}
+	vectors[CORNER_PRIO_LEFT].x = vectors[CORNER_LOD_LEFT].x * 0.2f;
+	vectors[CORNER_PRIO_LEFT].y = vectors[CORNER_LOD_LEFT].y * 0.2f;
+	vectors[CORNER_PRIO_LEFT].z = vectors[CORNER_LOD_LEFT].z;
+	vectors[CORNER_PRIO_RIGHT].x = vectors[CORNER_LOD_RIGHT].x * 0.2f;
+	vectors[CORNER_PRIO_RIGHT].y = vectors[CORNER_LOD_RIGHT].y * 0.2f;
+	vectors[CORNER_PRIO_RIGHT].z = vectors[CORNER_LOD_RIGHT].z;
+	RwV3dTransformPoints(vectors, vectors, 9, cammatrix);
+
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+#ifdef FIX_BUGS
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_GTACLASSIC ||
+#endif
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+		CRect rect;
+		int x1, x2, y1, y2;
+		LimitFrustumVector(vectors[CORNER_FAR_TOPLEFT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_TOPLEFT]);
+		LimitFrustumVector(vectors[CORNER_FAR_TOPRIGHT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_TOPRIGHT]);
+		LimitFrustumVector(vectors[CORNER_FAR_BOTRIGHT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_BOTRIGHT]);
+		LimitFrustumVector(vectors[CORNER_FAR_BOTLEFT], vectors[CORNER_CAM], -100.0f);
+		rect.ContainPoint(vectors[CORNER_FAR_BOTLEFT]);
+		x1 = CWorld::GetSectorIndexX(rect.left);
+		if(x1 < 0) x1 = 0;
+		x2 = CWorld::GetSectorIndexX(rect.right);
+		if(x2 >= NUMSECTORS_X-1) x2 = NUMSECTORS_X-1;
+		y1 = CWorld::GetSectorIndexY(rect.top);
+		if(y1 < 0) y1 = 0;
+		y2 = CWorld::GetSectorIndexY(rect.bottom);
+		if(y2 >= NUMSECTORS_Y-1) y2 = NUMSECTORS_Y-1;
+		for(; x1 <= x2; x1++)
+			for(int y = y1; y <= y2; y++)
+				ScanSectorList_RequestModels(CWorld::GetSector(x1, y)->m_lists);
+	}else{
+		poly[0].x = CWorld::GetSectorX(vectors[CORNER_CAM].x);
+		poly[0].y = CWorld::GetSectorY(vectors[CORNER_CAM].y);
+		poly[1].x = CWorld::GetSectorX(vectors[CORNER_LOD_LEFT].x);
+		poly[1].y = CWorld::GetSectorY(vectors[CORNER_LOD_LEFT].y);
+		poly[2].x = CWorld::GetSectorX(vectors[CORNER_LOD_RIGHT].x);
+		poly[2].y = CWorld::GetSectorY(vectors[CORNER_LOD_RIGHT].y);
+		ScanSectorPoly(poly, 3, ScanSectorList_RequestModels);
+	}
+}
+
+bool
+CEntity::SetupLighting(void)
+{
+	DeActivateDirectional();
+	SetAmbientColours();
+	return false;
+}
+
+void
+CEntity::RemoveLighting(bool)
+{
+}
+
+bool
+CPed::SetupLighting(void)
+{
+	ActivateDirectional();
+	SetAmbientColoursForPedsCarsAndObjects();
+
+#ifndef MASTER
+	// Originally this was being called through iteration of Sectors, but putting it here is better.
+	if (GetDebugDisplay() != 0 && !IsPlayer())
+		DebugRenderOnePedText();
+#endif
+
+	if (bRenderScorched) {
+		WorldReplaceNormalLightsWithScorched(Scene.world, 0.1f);
+	} else {
+		// Note that this lightMult is only affected by LIGHT_DARKEN. If there's no LIGHT_DARKEN, it will be 1.0.
+		float lightMult = CPointLights::GenerateLightsAffectingObject(&GetPosition());
+		if (!bHasBlip && lightMult != 1.0f) {
+			SetAmbientAndDirectionalColours(lightMult);
+			return true;
+		}
+	}
+	return false;
+}
+
+void
+CPed::RemoveLighting(bool reset)
+{
+	CRenderer::RemoveVehiclePedLights(this, reset);
+}
+
+float
+CalcNewDelta(RwV2d *a, RwV2d *b)
+{
+	return (b->x - a->x) / (b->y - a->y);
+}
+
+#ifdef FIX_BUGS
+#define TOINT(x) ((int)Floor(x))
+#else
+#define TOINT(x) ((int)(x))
+#endif
+
+void
+CRenderer::ScanSectorPoly(RwV2d *poly, int32 numVertices, void (*scanfunc)(CPtrList *))
+{
+	float miny, maxy;
+	int y, yend;
+	int x, xstart, xend;
+	int i;
+	int a1, a2, b1, b2;
+	float deltaA, deltaB;
+	float xA, xB;
+
+	miny = poly[0].y;
+	maxy = poly[0].y;
+	a2 = 0;
+	xstart = 9999;
+	xend = -9999;
+
+	for(i = 1; i < numVertices; i++){
+		if(poly[i].y > maxy)
+			maxy = poly[i].y;
+		if(poly[i].y < miny){
+			miny = poly[i].y;
+			a2 = i;
+		}
+	}
+	y = TOINT(miny);
+	yend = TOINT(maxy);
+
+	// Go left in poly to find first edge b
+	b2 = a2;
+	for(i = 0; i < numVertices; i++){
+		b1 = b2--;
+		if(b2 < 0) b2 = numVertices-1;
+		if(poly[b1].x < xstart)
+			xstart = TOINT(poly[b1].x);
+		if(TOINT(poly[b1].y) != TOINT(poly[b2].y))
+			break;
+	}
+	// Go right to find first edge a
+	for(i = 0; i < numVertices; i++){
+		a1 = a2++;
+		if(a2 == numVertices) a2 = 0;
+		if(poly[a1].x > xend)
+			xend = TOINT(poly[a1].x);
+		if(TOINT(poly[a1].y) != TOINT(poly[a2].y))
+			break;
+	}
+
+	// prestep x1 and x2 to next integer y
+	deltaA = CalcNewDelta(&poly[a1], &poly[a2]);
+	xA = deltaA * (Ceil(poly[a1].y) - poly[a1].y) + poly[a1].x;
+	deltaB = CalcNewDelta(&poly[b1], &poly[b2]);
+	xB = deltaB * (Ceil(poly[b1].y) - poly[b1].y) + poly[b1].x;
+
+	if(y != yend){
+		if(deltaB < 0.0f && TOINT(xB) < xstart)
+			xstart = TOINT(xB);
+		if(deltaA >= 0.0f && TOINT(xA) > xend)
+			xend = TOINT(xA);
+	}
+
+	while(y <= yend && y < NUMSECTORS_Y){
+		// scan one x-line
+		if(y >= 0 && xstart < NUMSECTORS_X)
+			for(x = xstart; x <= xend && x != NUMSECTORS_X; x++)
+				if(x >= 0)
+					scanfunc(CWorld::GetSector(x, y)->m_lists);
+
+		// advance one scan line
+		y++;
+		xA += deltaA;
+		xB += deltaB;
+
+		// update left side
+		if(y == TOINT(poly[b2].y)){
+			// reached end of edge
+			if(y == yend){
+				if(deltaB < 0.0f){
+					do{
+						xstart = TOINT(poly[b2--].x);
+						if(b2 < 0) b2 = numVertices-1;
+					}while(xstart > TOINT(poly[b2].x));
+				}else
+					xstart = TOINT(xB - deltaB);
+			}else{
+				// switch edges
+				if(deltaB < 0.0f)
+					xstart = TOINT(poly[b2].x);
+				else
+					xstart = TOINT(xB - deltaB);
+				do{
+					b1 = b2--;
+					if(b2 < 0) b2 = numVertices-1;
+					if(TOINT(poly[b1].x) < xstart)
+						xstart = TOINT(poly[b1].x);
+				}while(y == TOINT(poly[b2].y));
+				deltaB = CalcNewDelta(&poly[b1], &poly[b2]);
+				xB = deltaB * (Ceil(poly[b1].y) - poly[b1].y) + poly[b1].x;
+				if(deltaB < 0.0f && TOINT(xB) < xstart)
+					xstart = TOINT(xB);
+			}
+		}else{
+			if(deltaB < 0.0f)
+				xstart = TOINT(xB);
+			else
+				xstart = TOINT(xB - deltaB);
+		}
+
+		// update right side
+		if(y == TOINT(poly[a2].y)){
+			// reached end of edge
+			if(y == yend){
+				if(deltaA < 0.0f)
+					xend = TOINT(xA - deltaA);
+				else{
+					do{
+						xend = TOINT(poly[a2++].x);
+						if(a2 == numVertices) a2 = 0;
+					}while(xend < TOINT(poly[a2].x));
+				}
+			}else{
+				// switch edges
+				if(deltaA < 0.0f)
+					xend = TOINT(xA - deltaA);
+				else
+					xend = TOINT(poly[a2].x);
+				do{
+					a1 = a2++;
+					if(a2 == numVertices) a2 = 0;
+					if(TOINT(poly[a1].x) > xend)
+						xend = TOINT(poly[a1].x);
+				}while(y == TOINT(poly[a2].y));
+				deltaA = CalcNewDelta(&poly[a1], &poly[a2]);
+				xA = deltaA * (Ceil(poly[a1].y) - poly[a1].y) + poly[a1].x;
+				if(deltaA >= 0.0f && TOINT(xA) > xend)
+					xend = TOINT(xA);
+			}
+		}else{
+			if(deltaA < 0.0f)
+				xend = TOINT(xA - deltaA);
+			else
+				xend = TOINT(xA);
+		}
+	}
+}
+
+void
+CRenderer::InsertEntityIntoList(CEntity *ent)
+{
+#ifdef FIX_BUGS
+	if (!ent->m_rwObject) return;
+#endif
+
+#ifdef NEW_RENDERER
+	// TODO: there are more flags being checked here
+	if(gbNewRenderer && (ent->IsVehicle() || ent->IsPed()))
+		ms_aVisibleVehiclePtrs[ms_nNoOfVisibleVehicles++] = ent;
+	else if(gbNewRenderer && ent->IsBuilding()){
+		EntityInfo info;
+		info.ent = ent;
+		info.sort = -(ent->GetPosition() - ms_vecCameraPosition).MagnitudeSqr();
+		gSortedBuildings.InsertSorted(info);
+//		ms_aVisibleBuildingPtrs[ms_nNoOfVisibleBuildings++] = ent;
+	}else
+#endif
+		ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+}
+
+void
+CRenderer::ScanBigBuildingList(CPtrList &list)
+{
+	CPtrNode *node;
+	CEntity *ent;
+
+	for(node = list.first; node; node = node->next){
+		ent = (CEntity*)node->item;
+#ifndef MASTER
+		// all missing from game actually
+		TestedBigBuildings++;
+#endif
+		if(!ent->bZoneCulled || gbDisableZoneCull){
+			if(SetupBigBuildingVisibility(ent) == VIS_VISIBLE)
+				InsertEntityIntoList(ent);
+#ifndef MASTER
+			EntitiesRendered++;
+			RenderedBigBuildings++;
+		}else{
+			EntitiesNotRendered++;
+#endif
+		}
+	}
+}
+
+void
+CRenderer::ScanSectorList(CPtrList *lists)
+{
+	CPtrNode *node;
+	CPtrList *list;
+	CEntity *ent;
+	int i;
+	float dx, dy;
+
+	for(i = 0; i < NUMSECTORENTITYLISTS; i++){
+		list = &lists[i];
+		for(node = list->first; node; node = node->next){
+			ent = (CEntity*)node->item;
+			if(ent->m_scanCode == CWorld::GetCurrentScanCode())
+				continue;	// already seen
+			ent->m_scanCode = CWorld::GetCurrentScanCode();
+
+			if(IsEntityCullZoneVisible(ent)){
+				switch(SetupEntityVisibility(ent)){
+				case VIS_VISIBLE:
+					InsertEntityIntoList(ent);
+					break;
+				case VIS_INVISIBLE:
+					if(!IsGlass(ent->GetModelIndex()))
+						break;
+					// fall through
+				case VIS_OFFSCREEN:
+					dx = ms_vecCameraPosition.x - ent->GetPosition().x;
+					dy = ms_vecCameraPosition.y - ent->GetPosition().y;
+					if(dx > -65.0f && dx < 65.0f &&
+					   dy > -65.0f && dy < 65.0f &&
+					   ms_nNoOfInVisibleEntities < NUMINVISIBLEENTITIES - 1)
+						ms_aInVisibleEntityPtrs[ms_nNoOfInVisibleEntities++] = ent;
+					break;
+				case VIS_STREAMME:
+					if(!CStreaming::ms_disableStreaming)
+						if(!m_loadingPriority || CStreaming::ms_numModelsRequested < 10)
+							CStreaming::RequestModel(ent->GetModelIndex(), 0);
+					break;
+				}
+#ifndef MASTER
+				EntitiesRendered++;
+				switch(ent->GetType()){
+				case ENTITY_TYPE_BUILDING:
+					if(ent->bIsBIGBuilding)
+						RenderedBigBuildings++;
+					else
+						RenderedBuildings++;
+					break;
+				case ENTITY_TYPE_VEHICLE:
+					RenderedCars++;
+					break;
+				case ENTITY_TYPE_PED:
+					RenderedPeds++;
+					break;
+				case ENTITY_TYPE_OBJECT:
+					RenderedObjects++;
+					break;
+				case ENTITY_TYPE_DUMMY:
+					RenderedDummies++;
+					break;
+				}
+#endif
+			}else if(IsRoad(ent) && !CStreaming::ms_disableStreaming){
+				if(SetupEntityVisibility(ent) == VIS_STREAMME)
+					if(!m_loadingPriority || CStreaming::ms_numModelsRequested < 10)
+						CStreaming::RequestModel(ent->GetModelIndex(), 0);
+			}else{
+#ifndef MASTER
+				EntitiesNotRendered++;
+#endif
+			}
+		}
+	}
+}
+
+void
+CRenderer::ScanSectorList_Priority(CPtrList *lists)
+{
+	CPtrNode *node;
+	CPtrList *list;
+	CEntity *ent;
+	int i;
+	float dx, dy;
+
+	for(i = 0; i < NUMSECTORENTITYLISTS; i++){
+		list = &lists[i];
+		for(node = list->first; node; node = node->next){
+			ent = (CEntity*)node->item;
+			if(ent->m_scanCode == CWorld::GetCurrentScanCode())
+				continue;	// already seen
+			ent->m_scanCode = CWorld::GetCurrentScanCode();
+
+			if(IsEntityCullZoneVisible(ent)){
+				switch(SetupEntityVisibility(ent)){
+				case VIS_VISIBLE:
+					InsertEntityIntoList(ent);
+					break;
+				case VIS_INVISIBLE:
+					if(!IsGlass(ent->GetModelIndex()))
+						break;
+					// fall through
+				case VIS_OFFSCREEN:
+					dx = ms_vecCameraPosition.x - ent->GetPosition().x;
+					dy = ms_vecCameraPosition.y - ent->GetPosition().y;
+					if(dx > -65.0f && dx < 65.0f &&
+					   dy > -65.0f && dy < 65.0f &&
+					   ms_nNoOfInVisibleEntities < NUMINVISIBLEENTITIES - 1)
+						ms_aInVisibleEntityPtrs[ms_nNoOfInVisibleEntities++] = ent;
+					break;
+				case VIS_STREAMME:
+					if(!CStreaming::ms_disableStreaming){
+						CStreaming::RequestModel(ent->GetModelIndex(), 0);
+						if(CStreaming::ms_aInfoForModel[ent->GetModelIndex()].m_loadState != STREAMSTATE_LOADED)
+							m_loadingPriority = true;
+					}
+					break;
+				}
+#ifndef MASTER
+				// actually missing in game
+				EntitiesRendered++;
+				switch(ent->GetType()){
+				case ENTITY_TYPE_BUILDING:
+					if(ent->bIsBIGBuilding)
+						RenderedBigBuildings++;
+					else
+						RenderedBuildings++;
+					break;
+				case ENTITY_TYPE_VEHICLE:
+					RenderedCars++;
+					break;
+				case ENTITY_TYPE_PED:
+					RenderedPeds++;
+					break;
+				case ENTITY_TYPE_OBJECT:
+					RenderedObjects++;
+					break;
+				case ENTITY_TYPE_DUMMY:
+					RenderedDummies++;
+					break;
+				}
+#endif
+			}else if(IsRoad(ent) && !CStreaming::ms_disableStreaming){
+				if(SetupEntityVisibility(ent) == VIS_STREAMME)
+					CStreaming::RequestModel(ent->GetModelIndex(), 0);
+			}else{
+#ifndef MASTER
+				// actually missing in game
+				EntitiesNotRendered++;
+#endif
+			}
+		}
+	}
+}
+
+void
+CRenderer::ScanSectorList_Subway(CPtrList *lists)
+{
+	CPtrNode *node;
+	CPtrList *list;
+	CEntity *ent;
+	int i;
+	float dx, dy;
+
+	for(i = 0; i < NUMSECTORENTITYLISTS; i++){
+		list = &lists[i];
+		for(node = list->first; node; node = node->next){
+			ent = (CEntity*)node->item;
+			if(ent->m_scanCode == CWorld::GetCurrentScanCode())
+				continue;	// already seen
+			ent->m_scanCode = CWorld::GetCurrentScanCode();
+			switch(SetupEntityVisibility(ent)){
+			case VIS_VISIBLE:
+				InsertEntityIntoList(ent);
+				break;
+			case VIS_OFFSCREEN:
+				dx = ms_vecCameraPosition.x - ent->GetPosition().x;
+				dy = ms_vecCameraPosition.y - ent->GetPosition().y;
+				if(dx > -65.0f && dx < 65.0f &&
+				   dy > -65.0f && dy < 65.0f &&
+				   ms_nNoOfInVisibleEntities < NUMINVISIBLEENTITIES - 1)
+					ms_aInVisibleEntityPtrs[ms_nNoOfInVisibleEntities++] = ent;
+				break;
+			}
+		}
+	}
+}
+
+void
+CRenderer::ScanSectorList_RequestModels(CPtrList *lists)
+{
+	CPtrNode *node;
+	CPtrList *list;
+	CEntity *ent;
+	int i;
+
+	for(i = 0; i < NUMSECTORENTITYLISTS; i++){
+		list = &lists[i];
+		for(node = list->first; node; node = node->next){
+			ent = (CEntity*)node->item;
+			if(ent->m_scanCode == CWorld::GetCurrentScanCode())
+				continue;	// already seen
+			ent->m_scanCode = CWorld::GetCurrentScanCode();
+			if(IsEntityCullZoneVisible(ent))
+			if(ShouldModelBeStreamed(ent))
+				CStreaming::RequestModel(ent->GetModelIndex(), 0);
+		}
+	}
+}
+
+// Put big buildings in front
+// This seems pointless because the sector lists shouldn't have big buildings in the first place
+void
+CRenderer::SortBIGBuildings(void)
+{
+	int x, y;
+	for(y = 0; y < NUMSECTORS_Y; y++)
+		for(x = 0; x < NUMSECTORS_X; x++){
+			SortBIGBuildingsForSectorList(&CWorld::GetSector(x, y)->m_lists[ENTITYLIST_BUILDINGS]);
+			SortBIGBuildingsForSectorList(&CWorld::GetSector(x, y)->m_lists[ENTITYLIST_BUILDINGS_OVERLAP]);
+		}
+}
+
+void
+CRenderer::SortBIGBuildingsForSectorList(CPtrList *list)
+{
+	CPtrNode *node;
+	CEntity *ent;
+
+	for(node = list->first; node; node = node->next){
+		ent = (CEntity*)node->item;
+		if(ent->bIsBIGBuilding){
+			list->RemoveNode(node);
+			list->InsertNode(node);
+		}
+	}
+}
+
+bool
+CRenderer::ShouldModelBeStreamed(CEntity *ent)
+{
+	CSimpleModelInfo *mi = (CSimpleModelInfo *)CModelInfo::GetModelInfo(ent->GetModelIndex());
+	float dist = (ent->GetPosition() - ms_vecCameraPosition).Magnitude();
+	if(mi->m_noFade)
+		return dist - STREAM_DISTANCE < mi->GetLargestLodDistance();
+	else
+		return dist - FADE_DISTANCE - STREAM_DISTANCE < mi->GetLargestLodDistance();
+}
+
+bool
+CRenderer::IsEntityCullZoneVisible(CEntity *ent)
+{
+	CPed *ped;
+	CObject *obj;
+
+	if(gbDisableZoneCull) return true;
+
+#ifndef MASTER
+	switch(ent->GetType()){
+	case ENTITY_TYPE_BUILDING:
+		if(ent->bIsBIGBuilding)
+			TestedBigBuildings++;
+		else
+			TestedBuildings++;
+		break;
+	case ENTITY_TYPE_VEHICLE:
+		TestedCars++;
+		break;
+	case ENTITY_TYPE_PED:
+		TestedPeds++;
+		break;
+	case ENTITY_TYPE_OBJECT:
+		TestedObjects++;
+		break;
+	case ENTITY_TYPE_DUMMY:
+		TestedDummies++;
+		break;
+	}
+#endif
+	if(ent->bZoneCulled)
+		return false;
+
+
+	switch(ent->GetType()){
+	case ENTITY_TYPE_VEHICLE:
+		return IsVehicleCullZoneVisible(ent);
+	case ENTITY_TYPE_PED:
+		ped = (CPed*)ent;
+		if (ped->bInVehicle) {
+			if (ped->m_pMyVehicle)
+				return IsVehicleCullZoneVisible(ped->m_pMyVehicle);
+			else
+				return true;
+		}
+		return !(ped->m_pCurSurface && ped->m_pCurSurface->bZoneCulled2);
+	case ENTITY_TYPE_OBJECT:
+		obj = (CObject*)ent;
+		if(!obj->GetIsStatic())
+			return true;
+		return !(obj->m_pCurSurface && obj->m_pCurSurface->bZoneCulled2);
+	default: break;
+	}
+	return true;
+}
+
+bool
+CRenderer::IsVehicleCullZoneVisible(CEntity *ent)
+{
+	CVehicle *v = (CVehicle*)ent;
+	switch(v->GetStatus()) {
+	case STATUS_SIMPLE:
+	case STATUS_PHYSICS:
+	case STATUS_ABANDONED:
+	case STATUS_WRECKED:
+		return !(v->m_pCurGroundEntity && v->m_pCurGroundEntity->bZoneCulled2);
+	default: break;
+	}
+	return true;
+}
+
+void
+CRenderer::RemoveVehiclePedLights(CEntity *ent, bool reset)
+{
+	if(ent->bRenderScorched){
+		WorldReplaceScorchedLightsWithNormal(Scene.world);
+		return;
+	}
+	CPointLights::RemoveLightsAffectingObject();
+	if(reset)
+		ReSetAmbientAndDirectionalColours();
+}
diff --git a/src/renderer/Renderer.h b/src/renderer/Renderer.h
new file mode 100644
index 00000000..0322939c
--- /dev/null
+++ b/src/renderer/Renderer.h
@@ -0,0 +1,119 @@
+#pragma once
+
+class CEntity;
+
+#ifdef FIX_BUGS
+#define LOD_DISTANCE (300.0f*TheCamera.LODDistMultiplier)
+#else
+#define LOD_DISTANCE 300.0f
+#endif
+#define FADE_DISTANCE 20.0f
+#define STREAM_DISTANCE 30.0f
+
+#ifdef EXTRA_MODEL_FLAGS
+#define BACKFACE_CULLING_ON SetCullMode(rwCULLMODECULLBACK)
+#define BACKFACE_CULLING_OFF SetCullMode(rwCULLMODECULLNONE)
+#else
+#define BACKFACE_CULLING_ON
+#define BACKFACE_CULLING_OFF
+#endif
+
+extern bool gbShowPedRoadGroups;
+extern bool gbShowCarRoadGroups;
+extern bool gbShowCollisionPolys;
+extern bool gbShowCollisionLines;
+extern bool gbShowCullZoneDebugStuff;
+extern bool gbDisableZoneCull;	// not original
+extern bool gbBigWhiteDebugLightSwitchedOn;
+
+extern bool gbDontRenderBuildings;
+extern bool gbDontRenderBigBuildings;
+extern bool gbDontRenderPeds;
+extern bool gbDontRenderObjects;
+extern bool gbDontRenderVehicles;
+
+class CVehicle;
+class CPtrList;
+
+// unused
+struct BlockedRange
+{
+	float a, b;	// unknown
+	BlockedRange *prev, *next;
+};
+
+class CRenderer
+{
+	static int32 ms_nNoOfVisibleEntities;
+	static CEntity *ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
+	static int32 ms_nNoOfInVisibleEntities;
+	static CEntity *ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
+#ifdef NEW_RENDERER
+	static int32 ms_nNoOfVisibleVehicles;
+	static CEntity *ms_aVisibleVehiclePtrs[NUMVISIBLEENTITIES];
+	// for cWorldStream emulation
+	static int32 ms_nNoOfVisibleBuildings;
+	static CEntity *ms_aVisibleBuildingPtrs[NUMVISIBLEENTITIES];
+#endif
+
+	static CVector ms_vecCameraPosition;
+	static CVehicle *m_pFirstPersonVehicle;
+
+	// unused
+	static BlockedRange aBlockedRanges[16];
+	static BlockedRange *pFullBlockedRanges;
+	static BlockedRange *pEmptyBlockedRanges;
+public:
+	static float ms_lodDistScale;
+	static bool m_loadingPriority;
+
+	static void Init(void);
+	static void Shutdown(void);
+	static void PreRender(void);
+
+	static void RenderRoads(void);
+	static void RenderFadingInEntities(void);
+	static void RenderEverythingBarRoads(void);
+	static void RenderVehiclesButNotBoats(void);
+	static void RenderBoats(void);
+	static void RenderOneRoad(CEntity *);
+	static void RenderOneNonRoad(CEntity *);
+	static void RenderFirstPersonVehicle(void);
+
+	static void RenderCollisionLines(void);
+	// unused
+	static void RenderBlockBuildingLines(void);
+
+	static int32 SetupEntityVisibility(CEntity *ent);
+	static int32 SetupBigBuildingVisibility(CEntity *ent);
+
+	static void ConstructRenderList(void);
+	static void ScanWorld(void);
+	static void RequestObjectsInFrustum(void);
+	static void ScanSectorPoly(RwV2d *poly, int32 numVertices, void (*scanfunc)(CPtrList *));
+	static void ScanBigBuildingList(CPtrList &list);
+	static void ScanSectorList(CPtrList *lists);
+	static void ScanSectorList_Priority(CPtrList *lists);
+	static void ScanSectorList_Subway(CPtrList *lists);
+	static void ScanSectorList_RequestModels(CPtrList *lists);
+
+	static void SortBIGBuildings(void);
+	static void SortBIGBuildingsForSectorList(CPtrList *list);
+
+	static bool ShouldModelBeStreamed(CEntity *ent);
+	static bool IsEntityCullZoneVisible(CEntity *ent);
+	static bool IsVehicleCullZoneVisible(CEntity *ent);
+
+	static void RemoveVehiclePedLights(CEntity *ent, bool reset);
+
+
+#ifdef NEW_RENDERER
+	static void ClearForFrame(void);
+	static void RenderPeds(void);
+	static void RenderVehicles(void);	// also renders peds in LCS
+	static void RenderOneBuilding(CEntity *ent, float camdist = 0.0f);
+	static void RenderWorld(int pass);	// like cWorldStream::Render(int)
+	static void RenderWater(void);	// keep-out polys and water
+#endif
+	static void InsertEntityIntoList(CEntity *ent);
+};
diff --git a/src/renderer/Rubbish.cpp b/src/renderer/Rubbish.cpp
new file mode 100644
index 00000000..8da6b025
--- /dev/null
+++ b/src/renderer/Rubbish.cpp
@@ -0,0 +1,436 @@
+#include "common.h"
+#include "main.h"
+
+#include "General.h"
+#include "Timer.h"
+#include "Weather.h"
+#include "Camera.h"
+#include "World.h"
+#include "Vehicle.h"
+#include "ZoneCull.h"
+#include "TxdStore.h"
+#include "RenderBuffer.h"
+#include "Rubbish.h"
+
+#define RUBBISH_MAX_DIST (18.0f)
+#define RUBBISH_FADE_DIST (16.5f)
+
+RwTexture *gpRubbishTexture[4];
+RwImVertexIndex RubbishIndexList[6];
+RwImVertexIndex RubbishIndexList2[6];	// unused
+RwIm3DVertex RubbishVertices[4];
+bool CRubbish::bRubbishInvisible;
+int CRubbish::RubbishVisibility;
+COneSheet CRubbish::aSheets[NUM_RUBBISH_SHEETS];
+COneSheet CRubbish::StartEmptyList;
+COneSheet CRubbish::EndEmptyList;
+COneSheet CRubbish::StartStaticsList;
+COneSheet CRubbish::EndStaticsList;
+COneSheet CRubbish::StartMoversList;
+COneSheet CRubbish::EndMoversList;
+
+
+void
+COneSheet::AddToList(COneSheet *list)
+{
+	this->m_next = list->m_next;
+	this->m_prev = list;
+	list->m_next = this;
+	this->m_next->m_prev = this;
+}
+
+void
+COneSheet::RemoveFromList(void)
+{
+	m_next->m_prev = m_prev;
+	m_prev->m_next = m_next;
+}
+
+
+void
+CRubbish::Render(void)
+{
+	int type;
+
+	PUSH_RENDERGROUP("CRubbish::Render");
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+
+	for(type = 0; type < 4; type++){
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpRubbishTexture[type]));
+
+		TempBufferIndicesStored = 0;
+		TempBufferVerticesStored = 0;
+
+		COneSheet *sheet;
+		for(sheet = &aSheets[type*NUM_RUBBISH_SHEETS / 4];
+		    sheet < &aSheets[(type+1)*NUM_RUBBISH_SHEETS / 4];
+		    sheet++){
+			if(sheet->m_state == 0)
+				continue;
+
+			uint32 alpha = 128;
+			CVector pos;
+			if(sheet->m_state == 1){
+				pos = sheet->m_basePos;
+				if(!sheet->m_isVisible)
+					alpha = 0;
+			}else{
+				pos = sheet->m_animatedPos;
+				// Not fully visible during animation, calculate current alpha
+				if(!sheet->m_isVisible || !sheet->m_targetIsVisible){
+					float t = (float)(CTimer::GetTimeInMilliseconds() - sheet->m_moveStart)/sheet->m_moveDuration;
+					float f1 = sheet->m_isVisible ? 1.0f-t : 0.0f;
+					float f2 = sheet->m_targetIsVisible ? t : 0.0f;
+					alpha = 128 * (f1+f2);
+				}
+			}
+
+			float camDist = (pos - TheCamera.GetPosition()).Magnitude2D();
+			if(camDist < RUBBISH_MAX_DIST){
+				if(camDist >= RUBBISH_FADE_DIST)
+					alpha -= alpha*(camDist-RUBBISH_FADE_DIST)/(RUBBISH_MAX_DIST-RUBBISH_FADE_DIST);
+				alpha = (RubbishVisibility*alpha)/256;
+
+				float vx = Sin(sheet->m_angle) * 0.4f;
+				float vy = Cos(sheet->m_angle) * 0.4f;
+
+				int v = TempBufferVerticesStored;
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[v+0], pos.x + vx, pos.y + vy, pos.z);
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+0], 255, 255, 255, alpha);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[v+1], pos.x - vy, pos.y + vx, pos.z);
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+1], 255, 255, 255, alpha);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[v+2], pos.x + vy, pos.y - vx, pos.z);
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+2], 255, 255, 255, alpha);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[v+3], pos.x - vx, pos.y - vy, pos.z);
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+3], 255, 255, 255, alpha);
+				RwIm3DVertexSetU(&TempBufferRenderVertices[v+0], 0.0f);
+				RwIm3DVertexSetV(&TempBufferRenderVertices[v+0], 0.0f);
+				RwIm3DVertexSetU(&TempBufferRenderVertices[v+1], 1.0f);
+				RwIm3DVertexSetV(&TempBufferRenderVertices[v+1], 0.0f);
+				RwIm3DVertexSetU(&TempBufferRenderVertices[v+2], 0.0f);
+				RwIm3DVertexSetV(&TempBufferRenderVertices[v+2], 1.0f);
+				RwIm3DVertexSetU(&TempBufferRenderVertices[v+3], 1.0f);
+				RwIm3DVertexSetV(&TempBufferRenderVertices[v+3], 1.0f);
+
+				int i = TempBufferIndicesStored;
+				TempBufferRenderIndexList[i+0] = RubbishIndexList[0] + TempBufferVerticesStored;
+				TempBufferRenderIndexList[i+1] = RubbishIndexList[1] + TempBufferVerticesStored;
+				TempBufferRenderIndexList[i+2] = RubbishIndexList[2] + TempBufferVerticesStored;
+				TempBufferRenderIndexList[i+3] = RubbishIndexList[3] + TempBufferVerticesStored;
+				TempBufferRenderIndexList[i+4] = RubbishIndexList[4] + TempBufferVerticesStored;
+				TempBufferRenderIndexList[i+5] = RubbishIndexList[5] + TempBufferVerticesStored;
+				TempBufferVerticesStored += 4;
+				TempBufferIndicesStored += 6;
+			}
+		}
+
+		if(TempBufferIndicesStored != 0){
+			LittleTest();
+			if(RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV)){
+				RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+				RwIm3DEnd();
+			}
+		}
+	}
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+
+	POP_RENDERGROUP();
+}
+
+void
+CRubbish::StirUp(CVehicle *veh)
+{
+	if((CTimer::GetFrameCounter() ^ (veh->m_randomSeed&3)) == 0)
+		return;
+
+	if(Abs(veh->GetPosition().x - TheCamera.GetPosition().x) < 20.0f &&
+	   Abs(veh->GetPosition().y - TheCamera.GetPosition().y) < 20.0f)
+		if(Abs(veh->GetMoveSpeed().x) > 0.05f || Abs(veh->GetMoveSpeed().y) > 0.05f){
+			float speed = veh->GetMoveSpeed().Magnitude2D();
+			if(speed > 0.05f){
+				bool movingForward = DotProduct2D(veh->GetMoveSpeed(), veh->GetForward()) > 0.0f;
+				COneSheet *sheet = StartStaticsList.m_next;
+				CVector2D size = veh->GetColModel()->boundingBox.max;
+
+				// Check all static sheets
+				while(sheet != &EndStaticsList){
+					COneSheet *next = sheet->m_next;
+					CVector2D carToSheet = sheet->m_basePos - veh->GetPosition();
+					float distFwd = DotProduct2D(carToSheet, veh->GetForward());
+
+					// sheet has to be a bit behind car
+					if(movingForward && distFwd < -0.5f*size.y && distFwd > -1.5f*size.y ||
+					   !movingForward && distFwd > 0.5f*size.y && distFwd < 1.5f*size.y){
+						float distSide = Abs(DotProduct2D(carToSheet, veh->GetRight()));
+						if(distSide < 1.5*size.x){
+							// Check with higher speed for sheet directly behind car
+							float speedToCheck = distSide < size.x ? speed : speed*0.5f;
+							if(speedToCheck > 0.05f){
+								sheet->m_state = 2;
+								if(speedToCheck > 0.15f)
+									sheet->m_animationType = 2;
+								else
+									sheet->m_animationType = 1;
+								sheet->m_moveDuration = 2000;
+								sheet->m_xDist = veh->GetMoveSpeed().x;
+								sheet->m_yDist = veh->GetMoveSpeed().y;
+								float dist = Sqrt(SQR(sheet->m_xDist)+SQR(sheet->m_yDist));
+								sheet->m_xDist *= 25.0f*speed/dist;
+								sheet->m_yDist *= 25.0f*speed/dist;
+								sheet->m_animHeight = 3.0f*speed;
+								sheet->m_moveStart = CTimer::GetTimeInMilliseconds();
+								float tx = sheet->m_basePos.x + sheet->m_xDist;
+								float ty = sheet->m_basePos.y + sheet->m_yDist;
+								float tz = sheet->m_basePos.z + 3.0f;
+								sheet->m_targetZ = CWorld::FindGroundZFor3DCoord(tx, ty, tz, nil) + 0.1f;
+								sheet->RemoveFromList();
+								sheet->AddToList(&StartMoversList);
+							}
+						}
+					}
+
+					sheet = next;
+				}
+			}
+		}
+}
+
+static float aAnimations[3][34] = {
+	{ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },
+
+	// Normal move
+	{ 0.0f, 0.05f, 0.12f, 0.25f, 0.42f, 0.57f, 0.68f, 0.8f, 0.86f, 0.9f, 0.93f, 0.95f, 0.96f, 0.97f, 0.98f, 0.99f, 1.0f,	// XY movemnt
+	  0.15f, 0.35f, 0.6f, 0.9f, 1.2f, 1.25f, 1.3f, 1.2f, 1.1f, 0.95f, 0.8f, 0.6f, 0.45f, 0.3f, 0.2f, 0.1f, 0 },	// Z movement
+
+	// Stirred up by fast vehicle
+	{ 0.0f, 0.05f, 0.12f, 0.25f, 0.42f, 0.57f, 0.68f, 0.8f, 0.95f, 1.1f, 1.15f, 1.18f, 1.15f, 1.1f, 1.05f, 1.03f, 1.0f,
+	  0.15f, 0.35f, 0.6f, 0.9f, 1.2f, 1.25f, 1.3f, 1.2f, 1.1f, 0.95f, 0.8f, 0.6f, 0.45f, 0.3f, 0.2f, 0.1f, 0 }
+};
+
+void
+CRubbish::Update(void)
+{
+	bool foundGround;
+
+	// FRAMETIME
+	if(bRubbishInvisible)
+		RubbishVisibility = Max(RubbishVisibility-5, 0);
+	else
+		RubbishVisibility = Min(RubbishVisibility+5, 255);
+
+	// Spawn a new sheet
+	COneSheet *sheet = StartEmptyList.m_next;
+	if(sheet != &EndEmptyList){
+		float spawnDist;
+		float spawnAngle;
+
+		spawnDist = (CGeneral::GetRandomNumber()&0xFF)/256.0f + RUBBISH_MAX_DIST;
+		uint8 r = CGeneral::GetRandomNumber();
+		if(r&1)
+			spawnAngle = (CGeneral::GetRandomNumber()&0xFF)/256.0f * 6.28f;
+		else
+			spawnAngle = (r-128)/160.0f + TheCamera.Orientation;
+		sheet->m_basePos.x = TheCamera.GetPosition().x + spawnDist*Sin(spawnAngle);
+		sheet->m_basePos.y = TheCamera.GetPosition().y + spawnDist*Cos(spawnAngle);
+		sheet->m_basePos.z = CWorld::FindGroundZFor3DCoord(sheet->m_basePos.x, sheet->m_basePos.y, TheCamera.GetPosition().z, &foundGround) + 0.1f;
+		if(foundGround){
+			// Found ground, so add to statics list
+			sheet->m_angle = (CGeneral::GetRandomNumber()&0xFF)/256.0f * 6.28f;
+			sheet->m_state = 1;
+			if(CCullZones::FindAttributesForCoors(sheet->m_basePos, nil) & ATTRZONE_NORAIN)
+				sheet->m_isVisible = false;
+			else
+				sheet->m_isVisible = true;
+			sheet->RemoveFromList();
+			sheet->AddToList(&StartStaticsList);
+		}
+	}
+
+	// Process animation
+	sheet = StartMoversList.m_next;
+	while(sheet != &EndMoversList){
+		uint32 currentTime = CTimer::GetTimeInMilliseconds() - sheet->m_moveStart;
+		if(currentTime < sheet->m_moveDuration){
+			// Animation
+			int step = 16 * currentTime / sheet->m_moveDuration;	// 16 steps in animation
+			int stepTime = sheet->m_moveDuration/16;	// time in each step
+			float s = (float)(currentTime - stepTime*step) / stepTime;	// position on step
+			float t = (float)currentTime / sheet->m_moveDuration;	// position on total animation
+			// factors for xy and z-movment
+			float fxy = aAnimations[sheet->m_animationType][step]*(1.0f-s) + aAnimations[sheet->m_animationType][step+1]*s;
+			float fz = aAnimations[sheet->m_animationType][step+17]*(1.0f-s) + aAnimations[sheet->m_animationType][step+1+17]*s;
+			sheet->m_animatedPos.x = sheet->m_basePos.x + fxy*sheet->m_xDist;
+			sheet->m_animatedPos.y = sheet->m_basePos.y + fxy*sheet->m_yDist;
+			sheet->m_animatedPos.z = (1.0f-t)*sheet->m_basePos.z + t*sheet->m_targetZ + fz*sheet->m_animHeight;
+			sheet->m_angle += CTimer::GetTimeStep()*0.04f;
+			if(sheet->m_angle > 6.28f)
+				sheet->m_angle -= 6.28f;
+			sheet = sheet->m_next;
+		}else{
+			// End of animation, back into statics list
+			sheet->m_basePos.x += sheet->m_xDist;
+			sheet->m_basePos.y += sheet->m_yDist;
+			sheet->m_basePos.z = sheet->m_targetZ;
+			sheet->m_state = 1;
+			sheet->m_isVisible = sheet->m_targetIsVisible;
+
+			COneSheet *next = sheet->m_next;
+			sheet->RemoveFromList();
+			sheet->AddToList(&StartStaticsList);
+			sheet = next;
+		}
+	}
+
+	// Stir up a sheet by wind
+	// FRAMETIME
+	int freq;
+	if(CWeather::Wind < 0.1f)
+		freq = 31;
+	else if(CWeather::Wind < 0.4f)
+		freq = 7;
+	else if(CWeather::Wind < 0.7f)
+		freq = 1;
+	else
+		freq = 0;
+	if((CTimer::GetFrameCounter() & freq) == 0){
+		// Pick a random sheet and set animation state if static
+		int i = CGeneral::GetRandomNumber() % NUM_RUBBISH_SHEETS;
+		if(aSheets[i].m_state == 1){
+			aSheets[i].m_moveStart = CTimer::GetTimeInMilliseconds();
+			aSheets[i].m_moveDuration = CWeather::Wind*1500.0f + 1000.0f;
+			aSheets[i].m_animHeight = 0.2f;
+			aSheets[i].m_xDist = 3.0f*CWeather::Wind;
+			aSheets[i].m_yDist = 3.0f*CWeather::Wind;
+			// Check if target position is ok
+			float tx = aSheets[i].m_basePos.x + aSheets[i].m_xDist;
+			float ty = aSheets[i].m_basePos.y + aSheets[i].m_yDist;
+			float tz = aSheets[i].m_basePos.z + 3.0f;
+			aSheets[i].m_targetZ = CWorld::FindGroundZFor3DCoord(tx, ty, tz, &foundGround) + 0.1f;
+			if(CCullZones::FindAttributesForCoors(CVector(tx, ty, aSheets[i].m_targetZ), nil) & ATTRZONE_NORAIN)
+				aSheets[i].m_targetIsVisible = false;
+			else
+				aSheets[i].m_targetIsVisible = true;
+			if(foundGround){
+				// start animation
+				aSheets[i].m_state = 2;
+				aSheets[i].m_animationType = 1;
+				aSheets[i].RemoveFromList();
+				aSheets[i].AddToList(&StartMoversList);
+			}
+		}
+	}
+
+	// Remove sheets that are too far away
+	int i = (CTimer::GetFrameCounter()%(NUM_RUBBISH_SHEETS/4))*4;
+	int last = ((CTimer::GetFrameCounter()%(NUM_RUBBISH_SHEETS/4)) + 1)*4;
+	for(; i < last; i++){
+		if(aSheets[i].m_state == 1 &&
+		   (aSheets[i].m_basePos - TheCamera.GetPosition()).MagnitudeSqr2D() > SQR(RUBBISH_MAX_DIST+1.0f)){
+			aSheets[i].m_state = 0;
+			aSheets[i].RemoveFromList();
+			aSheets[i].AddToList(&StartEmptyList);
+		}
+	}
+}
+
+void
+CRubbish::SetVisibility(bool visible)
+{
+	bRubbishInvisible = !visible;
+}
+
+void
+CRubbish::Init(void)
+{
+	int i;
+	for(i = 0; i < NUM_RUBBISH_SHEETS; i++){
+		aSheets[i].m_state = 0;
+		if(i < NUM_RUBBISH_SHEETS-1)
+			aSheets[i].m_next = &aSheets[i+1];
+		else
+			aSheets[i].m_next = &EndEmptyList;
+		if(i > 0)
+			aSheets[i].m_prev = &aSheets[i-1];
+		else
+			aSheets[i].m_prev = &StartEmptyList;
+	}
+
+	StartEmptyList.m_next = &aSheets[0];
+	StartEmptyList.m_prev = nil;
+	EndEmptyList.m_next = nil;
+	EndEmptyList.m_prev = &aSheets[NUM_RUBBISH_SHEETS-1];
+
+	StartStaticsList.m_next = &EndStaticsList;
+	StartStaticsList.m_prev = nil;
+	EndStaticsList.m_next = nil;
+	EndStaticsList.m_prev = &StartStaticsList;
+
+	StartMoversList.m_next = &EndMoversList;
+	StartMoversList.m_prev = nil;
+	EndMoversList.m_next = nil;
+	EndMoversList.m_prev = &StartMoversList;
+
+	// unused
+	RwIm3DVertexSetU(&RubbishVertices[0], 0.0f);
+	RwIm3DVertexSetV(&RubbishVertices[0], 0.0f);
+	RwIm3DVertexSetU(&RubbishVertices[1], 1.0f);
+	RwIm3DVertexSetV(&RubbishVertices[1], 0.0f);
+	RwIm3DVertexSetU(&RubbishVertices[2], 0.0f);
+	RwIm3DVertexSetV(&RubbishVertices[2], 1.0f);
+	RwIm3DVertexSetU(&RubbishVertices[3], 1.0f);
+	RwIm3DVertexSetV(&RubbishVertices[3], 1.0f);
+
+	// unused
+	RubbishIndexList2[0] = 0;
+	RubbishIndexList2[1] = 2;
+	RubbishIndexList2[2] = 1;
+	RubbishIndexList2[3] = 1;
+	RubbishIndexList2[4] = 2;
+	RubbishIndexList2[5] = 3;
+
+	RubbishIndexList[0] = 0;
+	RubbishIndexList[1] = 1;
+	RubbishIndexList[2] = 2;
+	RubbishIndexList[3] = 1;
+	RubbishIndexList[4] = 3;
+	RubbishIndexList[5] = 2;
+
+	CTxdStore::PushCurrentTxd();
+	int slot = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::SetCurrentTxd(slot);
+	gpRubbishTexture[0] = RwTextureRead("gameleaf01_64", nil);
+	gpRubbishTexture[1] = RwTextureRead("gameleaf02_64", nil);
+	gpRubbishTexture[2] = RwTextureRead("newspaper01_64", nil);
+	gpRubbishTexture[3] = RwTextureRead("newspaper02_64", nil);
+	CTxdStore::PopCurrentTxd();
+	RubbishVisibility = 255;
+	bRubbishInvisible = false;
+}
+
+void
+CRubbish::Shutdown(void)
+{
+	RwTextureDestroy(gpRubbishTexture[0]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpRubbishTexture[0] = nil;
+#endif
+	RwTextureDestroy(gpRubbishTexture[1]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpRubbishTexture[1] = nil;
+#endif
+	RwTextureDestroy(gpRubbishTexture[2]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpRubbishTexture[2] = nil;
+#endif
+	RwTextureDestroy(gpRubbishTexture[3]);
+#if GTA_VERSION >= GTA3_PC_11
+	gpRubbishTexture[3] = nil;
+#endif
+}
diff --git a/src/renderer/Rubbish.h b/src/renderer/Rubbish.h
new file mode 100644
index 00000000..37f895f3
--- /dev/null
+++ b/src/renderer/Rubbish.h
@@ -0,0 +1,55 @@
+#pragma once
+
+class CVehicle;
+
+enum {
+	// NB: not all values are allowed, check the code
+#ifdef SQUEEZE_PERFORMANCE
+	NUM_RUBBISH_SHEETS = 32
+#else
+	NUM_RUBBISH_SHEETS = 64
+#endif
+};
+
+class COneSheet
+{
+public:
+	CVector m_basePos;
+	CVector m_animatedPos;
+	float m_targetZ;
+	int8 m_state;
+	int8 m_animationType;
+	uint32 m_moveStart;
+	uint32 m_moveDuration;
+	float m_animHeight;
+	float m_xDist;
+	float m_yDist;
+	float m_angle;
+	bool m_isVisible;
+	bool m_targetIsVisible;
+	COneSheet *m_next;
+	COneSheet *m_prev;
+
+	void AddToList(COneSheet *list);
+	void RemoveFromList(void);
+};
+
+class CRubbish
+{
+	static bool bRubbishInvisible;
+	static int RubbishVisibility;
+	static COneSheet aSheets[NUM_RUBBISH_SHEETS];
+	static COneSheet StartEmptyList;
+	static COneSheet EndEmptyList;
+	static COneSheet StartStaticsList;
+	static COneSheet EndStaticsList;
+	static COneSheet StartMoversList;
+	static COneSheet EndMoversList;
+public:
+	static void Render(void);
+	static void StirUp(CVehicle *veh);	// CAutomobile on PS2
+	static void Update(void);
+	static void SetVisibility(bool visible);
+	static void Init(void);
+	static void Shutdown(void);
+};
diff --git a/src/renderer/Shadows.cpp b/src/renderer/Shadows.cpp
new file mode 100644
index 00000000..3884d3bb
--- /dev/null
+++ b/src/renderer/Shadows.cpp
@@ -0,0 +1,1785 @@
+#include "common.h"
+
+#include "main.h"
+#include "TxdStore.h"
+#include "Timer.h"
+#include "Camera.h"
+#include "Timecycle.h"
+#include "CutsceneMgr.h"
+#include "Automobile.h"
+#include "Ped.h"
+#include "PlayerPed.h"
+#include "World.h"
+#include "Weather.h"
+#include "ModelIndices.h"
+#include "RenderBuffer.h"
+#ifdef FIX_BUGS
+#include "Replay.h"
+#endif
+#include "PointLights.h"
+#include "SpecialFX.h"
+#include "Shadows.h"
+
+#ifdef DEBUGMENU
+//SETTWEAKPATH("Shadows");
+//TWEAKBOOL(gbPrintShite);
+#endif
+
+RwImVertexIndex ShadowIndexList[24];
+
+RwTexture *gpShadowCarTex;
+RwTexture *gpShadowPedTex;
+RwTexture *gpShadowHeliTex;
+RwTexture *gpShadowExplosionTex;
+RwTexture *gpShadowHeadLightsTex;
+RwTexture *gpOutline1Tex;
+RwTexture *gpOutline2Tex;
+RwTexture *gpOutline3Tex;
+RwTexture *gpBloodPoolTex;
+RwTexture *gpReflectionTex;
+RwTexture *gpGoalMarkerTex;
+RwTexture *gpWalkDontTex;
+RwTexture *gpCrackedGlassTex;
+RwTexture *gpPostShadowTex;
+RwTexture *gpGoalTex;
+
+int16            CShadows::ShadowsStoredToBeRendered;
+CStoredShadow    CShadows::asShadowsStored  [MAX_STOREDSHADOWS];
+CPolyBunch       CShadows::aPolyBunches     [MAX_POLYBUNCHES];
+CStaticShadow    CShadows::aStaticShadows   [MAX_STATICSHADOWS];
+CPolyBunch      *CShadows::pEmptyBunchList;
+CPermanentShadow CShadows::aPermanentShadows[MAX_PERMAMENTSHADOWS];
+
+
+void
+CShadows::Init(void)
+{
+	CTxdStore::PushCurrentTxd();
+
+	int32 slut = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::SetCurrentTxd(slut);
+
+	gpShadowCarTex        = RwTextureRead("shad_car",     NULL);
+	gpShadowPedTex        = RwTextureRead("shad_ped",     NULL);
+	gpShadowHeliTex       = RwTextureRead("shad_heli",    NULL);
+	gpShadowExplosionTex  = RwTextureRead("shad_exp",     NULL);
+	gpShadowHeadLightsTex = RwTextureRead("headlight",    NULL);
+	gpOutline1Tex         = RwTextureRead("outline_64",   NULL);
+	gpOutline2Tex         = RwTextureRead("outline2_64",  NULL);
+	gpOutline3Tex         = RwTextureRead("outline3_64",  NULL);
+	gpBloodPoolTex        = RwTextureRead("bloodpool_64", NULL);
+	gpReflectionTex       = RwTextureRead("reflection01", NULL);
+	gpGoalMarkerTex       = RwTextureRead("goal",         NULL);
+	gpWalkDontTex         = RwTextureRead("walk_dont",    NULL);
+	gpCrackedGlassTex     = RwTextureRead("wincrack_32",  NULL);
+	gpPostShadowTex       = RwTextureRead("lamp_shad_64", NULL);
+
+	CTxdStore::PopCurrentTxd();
+
+	ASSERT(gpShadowCarTex != NULL);
+	ASSERT(gpShadowPedTex != NULL);
+	ASSERT(gpShadowHeliTex != NULL);
+	ASSERT(gpShadowExplosionTex != NULL);
+	ASSERT(gpShadowHeadLightsTex != NULL);
+	ASSERT(gpOutline1Tex != NULL);
+	ASSERT(gpOutline2Tex != NULL);
+	ASSERT(gpOutline3Tex != NULL);
+	ASSERT(gpBloodPoolTex != NULL);
+	ASSERT(gpReflectionTex != NULL);
+	ASSERT(gpGoalMarkerTex != NULL);
+	ASSERT(gpWalkDontTex != NULL);
+	ASSERT(gpCrackedGlassTex != NULL);
+	ASSERT(gpPostShadowTex != NULL);
+
+
+	ShadowIndexList[0] = 0;
+	ShadowIndexList[1] = 2;
+	ShadowIndexList[2] = 1;
+
+	ShadowIndexList[3] = 0;
+	ShadowIndexList[4] = 3;
+	ShadowIndexList[5] = 2;
+
+	ShadowIndexList[6] = 0;
+	ShadowIndexList[7] = 4;
+	ShadowIndexList[8] = 3;
+
+	ShadowIndexList[9] = 0;
+	ShadowIndexList[10] = 5;
+	ShadowIndexList[11] = 4;
+
+	ShadowIndexList[12] = 0;
+	ShadowIndexList[13] = 6;
+	ShadowIndexList[14] = 5;
+
+	ShadowIndexList[15] = 0;
+	ShadowIndexList[16] = 7;
+	ShadowIndexList[17] = 6;
+
+	ShadowIndexList[18] = 0;
+	ShadowIndexList[19] = 8;
+	ShadowIndexList[20] = 7;
+
+	ShadowIndexList[21] = 0;
+	ShadowIndexList[22] = 9;
+	ShadowIndexList[23] = 8;
+
+
+	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
+	{
+		aStaticShadows[i].m_nId = 0;
+		aStaticShadows[i].m_pPolyBunch = NULL;
+	}
+
+	pEmptyBunchList = &aPolyBunches[0];
+
+	for ( int32 i = 0; i < MAX_POLYBUNCHES; i++ )
+	{
+		if ( i == MAX_POLYBUNCHES - 1 )
+			aPolyBunches[i].m_pNext = NULL;
+		else
+			aPolyBunches[i].m_pNext = &aPolyBunches[i + 1];
+	}
+
+	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
+	{
+		aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
+	}
+}
+
+void
+CShadows::Shutdown(void)
+{
+	ASSERT(gpShadowCarTex != NULL);
+	ASSERT(gpShadowPedTex != NULL);
+	ASSERT(gpShadowHeliTex != NULL);
+	ASSERT(gpShadowExplosionTex != NULL);
+	ASSERT(gpShadowHeadLightsTex != NULL);
+	ASSERT(gpOutline1Tex != NULL);
+	ASSERT(gpOutline2Tex != NULL);
+	ASSERT(gpOutline3Tex != NULL);
+	ASSERT(gpBloodPoolTex != NULL);
+	ASSERT(gpReflectionTex != NULL);
+	ASSERT(gpGoalMarkerTex != NULL);
+	ASSERT(gpWalkDontTex != NULL);
+	ASSERT(gpCrackedGlassTex != NULL);
+	ASSERT(gpPostShadowTex != NULL);
+
+	RwTextureDestroy(gpShadowCarTex);
+	RwTextureDestroy(gpShadowPedTex);
+	RwTextureDestroy(gpShadowHeliTex);
+	RwTextureDestroy(gpShadowExplosionTex);
+	RwTextureDestroy(gpShadowHeadLightsTex);
+	RwTextureDestroy(gpOutline1Tex);
+	RwTextureDestroy(gpOutline2Tex);
+	RwTextureDestroy(gpOutline3Tex);
+	RwTextureDestroy(gpBloodPoolTex);
+	RwTextureDestroy(gpReflectionTex);
+	RwTextureDestroy(gpGoalMarkerTex);
+	RwTextureDestroy(gpWalkDontTex);
+	RwTextureDestroy(gpCrackedGlassTex);
+	RwTextureDestroy(gpPostShadowTex);
+}
+
+void
+CShadows::AddPermanentShadow(uint8 ShadowType, RwTexture *pTexture, CVector *pPosn,
+							float fFrontX, float fFrontY, float fSideX, float fSideY,
+							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
+							float fZDistance, uint32 nTime, float fScale)
+{
+	ASSERT(pTexture != NULL);
+	ASSERT(pPosn != NULL);
+
+
+	// find free slot
+	int32 nSlot = 0;
+	while ( nSlot < MAX_PERMAMENTSHADOWS && aPermanentShadows[nSlot].m_nType != SHADOWTYPE_NONE )
+		nSlot++;
+
+	if ( nSlot < MAX_PERMAMENTSHADOWS )
+	{
+		aPermanentShadows[nSlot].m_nType        = ShadowType;
+		aPermanentShadows[nSlot].m_pTexture     = pTexture;
+		aPermanentShadows[nSlot].m_vecPos       = *pPosn;
+		aPermanentShadows[nSlot].m_vecFront.x   = fFrontX;
+		aPermanentShadows[nSlot].m_vecFront.y   = fFrontY;
+		aPermanentShadows[nSlot].m_vecSide.x    = fSideX;
+		aPermanentShadows[nSlot].m_vecSide.y    = fSideY;
+		aPermanentShadows[nSlot].m_nIntensity   = nIntensity;
+		aPermanentShadows[nSlot].m_nRed         = nRed;
+		aPermanentShadows[nSlot].m_nGreen       = nGreen;
+		aPermanentShadows[nSlot].m_nBlue        = nBlue;
+		aPermanentShadows[nSlot].m_fZDistance   = fZDistance;
+		aPermanentShadows[nSlot].m_nLifeTime    = nTime;
+		aPermanentShadows[nSlot].m_nTimeCreated = CTimer::GetTimeInMilliseconds();
+	}
+}
+
+void
+CShadows::StoreStaticShadow(uint32 nID, uint8 ShadowType, RwTexture *pTexture, Const CVector *pPosn,
+							float fFrontX, float fFrontY, float fSideX, float fSideY,
+							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
+							float fZDistance, float fScale, float fDrawDistance, bool bTempShadow, float fUpDistance)
+{
+	ASSERT(pPosn != NULL);
+
+	float fDistToCamSqr = (*pPosn - TheCamera.GetPosition()).MagnitudeSqr2D();
+
+	if ( SQR(fDrawDistance) > fDistToCamSqr)
+	{
+		float fDistToCam = Sqrt(fDistToCamSqr);
+
+		if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) )
+		{
+			//fDistToCam == 0             -> 4
+			//fDistToCam == fDrawDistance -> 0
+			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/4.0f))));
+
+			nIntensity = (int32)(nIntensity * fMult);
+			nRed       = (int32)(nRed       * fMult);
+			nGreen     = (int32)(nGreen     * fMult);
+			nBlue      = (int32)(nBlue      * fMult);
+		}
+
+		int32 nSlot;
+
+		nSlot = 0;
+		while ( nSlot < MAX_STATICSHADOWS && !(nID == aStaticShadows[nSlot].m_nId && aStaticShadows[nSlot].m_pPolyBunch != NULL) )
+			nSlot++;
+
+		if ( nSlot < MAX_STATICSHADOWS )
+		{
+			if (   Abs(pPosn->x - aStaticShadows[nSlot].m_vecPosn.x) < fUpDistance
+				&& Abs(pPosn->y - aStaticShadows[nSlot].m_vecPosn.y) < fUpDistance )
+			{
+				aStaticShadows[nSlot].m_bJustCreated     = true;
+				aStaticShadows[nSlot].m_nType            = ShadowType;
+				aStaticShadows[nSlot].m_pTexture         = pTexture;
+				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
+				aStaticShadows[nSlot].m_nRed             = nRed;
+				aStaticShadows[nSlot].m_nGreen           = nGreen;
+				aStaticShadows[nSlot].m_nBlue            = nBlue;
+				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
+				aStaticShadows[nSlot].m_fScale           = fScale;
+				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
+				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
+			}
+            else if (  Abs(pPosn->x - aStaticShadows[nSlot].m_vecPosn.x) < 0.05f
+					&& Abs(pPosn->y - aStaticShadows[nSlot].m_vecPosn.y) < 0.05f
+					&& Abs(pPosn->z - aStaticShadows[nSlot].m_vecPosn.z) < 2.0f
+
+					&& fFrontX == aStaticShadows[nSlot].m_vecFront.x
+					&& fFrontY == aStaticShadows[nSlot].m_vecFront.y
+					&& fSideX  == aStaticShadows[nSlot].m_vecSide.x
+					&& fSideY  == aStaticShadows[nSlot].m_vecSide.y )
+			{
+				aStaticShadows[nSlot].m_bJustCreated     = true;
+				aStaticShadows[nSlot].m_nType            = ShadowType;
+				aStaticShadows[nSlot].m_pTexture         = pTexture;
+				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
+				aStaticShadows[nSlot].m_nRed             = nRed;
+				aStaticShadows[nSlot].m_nGreen           = nGreen;
+				aStaticShadows[nSlot].m_nBlue            = nBlue;
+				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
+				aStaticShadows[nSlot].m_fScale           = fScale;
+				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
+				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
+			}
+			else
+			{
+				aStaticShadows[nSlot].Free();
+
+				aStaticShadows[nSlot].m_nId              = nID;
+				aStaticShadows[nSlot].m_nType            = ShadowType;
+				aStaticShadows[nSlot].m_pTexture         = pTexture;
+				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
+				aStaticShadows[nSlot].m_nRed             = nRed;
+				aStaticShadows[nSlot].m_nGreen           = nGreen;
+				aStaticShadows[nSlot].m_nBlue            = nBlue;
+				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
+				aStaticShadows[nSlot].m_fScale           = fScale;
+				aStaticShadows[nSlot].m_vecPosn          = *pPosn;
+				aStaticShadows[nSlot].m_vecFront.x       = fFrontX;
+				aStaticShadows[nSlot].m_vecFront.y       = fFrontY;
+				aStaticShadows[nSlot].m_vecSide.x        = fSideX;
+				aStaticShadows[nSlot].m_vecSide.y        = fSideY;
+				aStaticShadows[nSlot].m_bJustCreated     = true;
+				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
+				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
+
+				GeneratePolysForStaticShadow(nSlot);
+			}
+		}
+		else
+		{
+			nSlot = 0;
+			while ( nSlot < MAX_STATICSHADOWS && aStaticShadows[nSlot].m_pPolyBunch != NULL )
+				nSlot++;
+
+			if ( nSlot != MAX_STATICSHADOWS )
+			{
+				aStaticShadows[nSlot].m_nId              = nID;
+				aStaticShadows[nSlot].m_nType            = ShadowType;
+				aStaticShadows[nSlot].m_pTexture         = pTexture;
+				aStaticShadows[nSlot].m_nIntensity       = nIntensity;
+				aStaticShadows[nSlot].m_nRed             = nRed;
+				aStaticShadows[nSlot].m_nGreen           = nGreen;
+				aStaticShadows[nSlot].m_nBlue            = nBlue;
+				aStaticShadows[nSlot].m_fZDistance       = fZDistance;
+				aStaticShadows[nSlot].m_fScale           = fScale;
+				aStaticShadows[nSlot].m_vecPosn          = *pPosn;
+				aStaticShadows[nSlot].m_vecFront.x       = fFrontX;
+				aStaticShadows[nSlot].m_vecFront.y       = fFrontY;
+				aStaticShadows[nSlot].m_vecSide.x        = fSideX;
+				aStaticShadows[nSlot].m_vecSide.y        = fSideY;
+				aStaticShadows[nSlot].m_bJustCreated     = true;
+				aStaticShadows[nSlot].m_bTemp            = bTempShadow;
+				aStaticShadows[nSlot].m_nTimeCreated     = CTimer::GetTimeInMilliseconds();
+
+				GeneratePolysForStaticShadow(nSlot);
+			}
+		}
+	}
+}
+
+void
+CShadows::StoreShadowToBeRendered(uint8 ShadowTexture, CVector *pPosn,
+								float fFrontX, float fFrontY, float fSideX, float fSideY,
+								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue)
+{
+	ASSERT(pPosn != NULL);
+
+	switch ( ShadowTexture )
+	{
+		case SHADOWTEX_NONE:
+		{
+			break;
+		}
+
+		case SHADOWTEX_CAR:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+
+		case SHADOWTEX_PED:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+
+		case SHADOWTEX_EXPLOSION:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowExplosionTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+
+		case SHADOWTEX_HELI:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowHeliTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+
+		case SHADOWTEX_HEADLIGHTS:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowHeadLightsTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+
+		case SHADOWTEX_BLOOD:
+		{
+			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpBloodPoolTex, pPosn,
+					fFrontX, fFrontY, fSideX, fSideY,
+					nIntensity, nRed, nGreen, nBlue,
+					15.0f, false, 1.0f);
+
+			break;
+		}
+	}
+
+	//ASSERT(false);
+}
+
+void
+CShadows::StoreShadowToBeRendered(uint8 ShadowType, RwTexture *pTexture, CVector *pPosn,
+								float fFrontX, float fFrontY, float fSideX, float fSideY,
+								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
+								float fZDistance, bool bDrawOnWater, float fScale)
+{
+	ASSERT(pTexture != NULL);
+	ASSERT(pPosn != NULL);
+
+	if ( ShadowsStoredToBeRendered < MAX_STOREDSHADOWS )
+	{
+		asShadowsStored[ShadowsStoredToBeRendered].m_ShadowType          = ShadowType;
+		asShadowsStored[ShadowsStoredToBeRendered].m_pTexture            = pTexture;
+		asShadowsStored[ShadowsStoredToBeRendered].m_vecPos              = *pPosn;
+		asShadowsStored[ShadowsStoredToBeRendered].m_vecFront.x          = fFrontX;
+		asShadowsStored[ShadowsStoredToBeRendered].m_vecFront.y          = fFrontY;
+		asShadowsStored[ShadowsStoredToBeRendered].m_vecSide.x           = fSideX;
+		asShadowsStored[ShadowsStoredToBeRendered].m_vecSide.y           = fSideY;
+		asShadowsStored[ShadowsStoredToBeRendered].m_nIntensity          = nIntensity;
+		asShadowsStored[ShadowsStoredToBeRendered].m_nRed                = nRed;
+		asShadowsStored[ShadowsStoredToBeRendered].m_nGreen              = nGreen;
+		asShadowsStored[ShadowsStoredToBeRendered].m_nBlue               = nBlue;
+		asShadowsStored[ShadowsStoredToBeRendered].m_fZDistance          = fZDistance;
+		asShadowsStored[ShadowsStoredToBeRendered].m_nFlags.bDrawOnWater = bDrawOnWater;
+		asShadowsStored[ShadowsStoredToBeRendered].m_fScale              = fScale;
+
+		ShadowsStoredToBeRendered++;
+	}
+}
+
+void
+CShadows::StoreShadowForCar(CAutomobile *pCar)
+{
+	ASSERT(pCar != NULL);
+
+	if ( CTimeCycle::GetShadowStrength() != 0 )
+	{
+		CVector CarPos = pCar->GetPosition();
+		float fDistToCamSqr = (CarPos - TheCamera.GetPosition()).MagnitudeSqr2D();
+
+		if ( CCutsceneMgr::IsRunning() )
+			fDistToCamSqr /= SQR(TheCamera.LODDistMultiplier) * 4.0f;
+
+		float fDrawDistance = 18.0f;
+
+		if ( fDistToCamSqr < SQR(fDrawDistance) )
+		{
+			float fDistToCam = Sqrt(fDistToCamSqr);
+			
+			//fDistToCam == 0             -> 4
+			//fDistToCam == fDrawDistance -> 0
+			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/4.0f))) );
+
+			int32 nColorStrength;
+
+			if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) )
+				nColorStrength = (int32)(CTimeCycle::GetShadowStrength() * fMult);
+			else
+				nColorStrength = CTimeCycle::GetShadowStrength();
+
+			float fVehicleHeight  = pCar->GetColModel()->boundingBox.GetSize().y;
+			float fVehicleWidth   = pCar->GetColModel()->boundingBox.GetSize().x;
+
+			if ( pCar->GetModelIndex() == MI_DODO )
+			{
+				fVehicleHeight *= 0.9f;
+				fVehicleWidth  *= 0.4f;
+			}
+
+			CarPos.x -= pCar->GetForward().x * ((fVehicleHeight / 2) - pCar->GetColModel()->boundingBox.max.y);
+			CarPos.y -= pCar->GetForward().y * ((fVehicleHeight / 2) - pCar->GetColModel()->boundingBox.max.y);
+
+			if ( pCar->GetUp().z > 0.0f )
+			{
+				StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &CarPos,
+					pCar->GetForward().x * (fVehicleHeight / 2),
+					pCar->GetForward().y * (fVehicleHeight / 2),
+					pCar->GetRight().x   * (fVehicleWidth  / 2),
+					pCar->GetRight().y   * (fVehicleWidth  / 2),
+					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
+					4.5f, false, 1.0f);
+			}
+			else
+			{
+				StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &CarPos,
+					pCar->GetForward().x * (fVehicleHeight / 2),
+					pCar->GetForward().y * (fVehicleHeight / 2),
+					-pCar->GetRight().x  * (fVehicleWidth  / 2),
+					-pCar->GetRight().y  * (fVehicleWidth  / 2),
+					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
+					4.5f, false, 1.0f);
+			}
+		}
+	}
+}
+
+void
+CShadows::StoreCarLightShadow(CAutomobile *pCar, int32 nID, RwTexture *pTexture, CVector *pPosn,
+							float fFrontX, float fFrontY, float fSideX, float fSideY, uint8 nRed, uint8 nGreen, uint8 nBlue,
+							float fMaxViewAngle)
+{
+	ASSERT(pCar != NULL);
+	ASSERT(pPosn != NULL);
+
+	float fDistToCamSqr = (*pPosn - TheCamera.GetPosition()).MagnitudeSqr2D();
+
+	bool bSpecialCam =     TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN
+						|| TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED
+						|| CCutsceneMgr::IsRunning();
+
+	float fDrawDistance = 27.0f;
+
+	if ( fDistToCamSqr < SQR(fDrawDistance) || bSpecialCam )
+	{
+		if ( bSpecialCam || DotProduct2D(CVector2D(TheCamera.CamFrontXNorm, TheCamera.CamFrontYNorm),
+											*pPosn - TheCamera.GetPosition() ) > -fMaxViewAngle )
+		{
+			float fDistToCam = Sqrt(fDistToCamSqr);
+
+			if ( fDistToCam >= (fDrawDistance*(1.0f-(1.0f/4.0f))) && !bSpecialCam ) // BUG? must be 3.0?
+			{
+				//fDistToCam == 0             -> 3
+				//fDistToCam == fDrawDistance -> 0
+				float fMult = 1.0f - (3.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f-(1.0f/3.0f))) );
+
+				nRed   = (int32)(nRed   * fMult);
+				nGreen = (int32)(nGreen * fMult);
+				nBlue  = (int32)(nBlue  * fMult);
+			}
+
+			StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, pTexture, pPosn,
+					fFrontX, fFrontY,
+					fSideX, fSideY,
+					128, nRed, nGreen, nBlue,
+					6.0f, false, 1.0f);
+
+		}
+	}
+}
+
+void
+CShadows::StoreShadowForPed(CPed *pPed, float fDisplacementX, float fDisplacementY,
+							float fFrontX, float fFrontY, float fSideX, float fSideY)
+{
+	ASSERT(pPed != NULL);
+
+	if ( pPed->bIsVisible )
+	{
+		if ( !(pPed->bInVehicle && pPed->m_nPedState != PED_DRAG_FROM_CAR && pPed->m_nPedState != PED_EXIT_CAR) )
+		{
+			if ( CTimeCycle::GetShadowStrength() != 0 )
+				StoreShadowForPedObject(pPed,
+					fDisplacementX, fDisplacementY,
+					fFrontX, fFrontY,
+					fSideX, fSideY);
+		}
+	}
+}
+
+void
+CShadows::StoreShadowForPedObject(CEntity *pPedObject, float fDisplacementX, float fDisplacementY,
+								float fFrontX, float fFrontY, float fSideX, float fSideY)
+{
+	ASSERT(pPedObject != NULL);
+
+	CVector PedPos = pPedObject->GetPosition();
+
+	float fDistToCamSqr = (PedPos - TheCamera.GetPosition()).MagnitudeSqr2D();
+
+	float fDrawDistance = 26.0f;
+
+	if ( fDistToCamSqr < SQR(fDrawDistance*0.5f)/*?*/ )
+	{
+		if ( pPedObject == FindPlayerPed() || TheCamera.IsSphereVisible(PedPos, 2.0f) != false )
+		{
+			float fDistToCam = Sqrt(fDistToCamSqr);
+
+			//fDistToCam == 0             ->  2
+			//fDistToCam == fDrawDistance -> -2
+			float fMult = 1.0f - (4.0f / fDrawDistance) * (fDistToCam - (fDrawDistance*(1.0f/4.0f))); // BUG ? negative
+			int32 nColorStrength;
+
+			if ( fDistToCam >= (fDrawDistance*(1.0f/4.0f)) ) // BUG ? negative
+				nColorStrength = (int32)(CTimeCycle::GetShadowStrength() * fMult);
+			else
+				nColorStrength = CTimeCycle::GetShadowStrength();
+
+			PedPos.x += fDisplacementX;
+			PedPos.y += fDisplacementY;
+
+			StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, &PedPos,
+					fFrontX, fFrontY,
+					fSideX, fSideY,
+					nColorStrength, nColorStrength, nColorStrength, nColorStrength,
+					4.0f, false, 1.0f);
+		}
+	}
+}
+
+void
+CShadows::StoreShadowForTree(CEntity *pTree)
+{
+	ASSERT(pTree != NULL);
+}
+
+void
+CShadows::StoreShadowForPole(CEntity *pPole, float fOffsetX, float fOffsetY, float fOffsetZ,
+								float fPoleHeight, float fPoleWidth, uint32 nID)
+{
+	ASSERT(pPole != NULL);
+
+	if ( CTimeCycle::GetShadowStrength() != 0 )
+	{
+		if ( pPole->GetUp().z < 0.5f )
+			return;
+
+		CVector PolePos = pPole->GetPosition();
+
+		PolePos.x += fOffsetX * pPole->GetRight().x + fOffsetY * pPole->GetForward().x;
+		PolePos.y += fOffsetX * pPole->GetRight().y + fOffsetY * pPole->GetForward().y;
+		PolePos.z += fOffsetZ;
+
+		PolePos.x += -CTimeCycle::GetSunDirection().x * (fPoleHeight / 2);
+		PolePos.y += -CTimeCycle::GetSunDirection().y * (fPoleHeight / 2);
+
+		StoreStaticShadow((uintptr)pPole + nID + _TODOCONST(51), SHADOWTYPE_DARK, gpPostShadowTex, &PolePos,
+				-CTimeCycle::GetSunDirection().x * (fPoleHeight / 2),
+				-CTimeCycle::GetSunDirection().y * (fPoleHeight / 2),
+				CTimeCycle::GetShadowSideX()    * fPoleWidth,
+				CTimeCycle::GetShadowSideY()    * fPoleWidth,
+				2 * (int32)((pPole->GetUp().z - 0.5f) * CTimeCycle::GetShadowStrength() * 2.0f) / 3,
+				0, 0, 0,
+				15.0f, 1.0f, 40.0f, false, 0.0f);
+	}
+}
+
+void
+CShadows::SetRenderModeForShadowType(uint8 ShadowType)
+{
+	switch ( ShadowType )
+	{
+		case SHADOWTYPE_DARK:
+		{
+			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDSRCALPHA);
+			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCALPHA);
+			break;
+		}
+
+		case SHADOWTYPE_ADDITIVE:
+		{
+			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDONE);
+			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDONE);
+			break;
+		}
+
+		case SHADOWTYPE_INVCOLOR:
+		{
+			RwRenderStateSet(rwRENDERSTATESRCBLEND,  (void *)rwBLENDZERO);
+			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDINVSRCCOLOR);
+			break;
+		}
+	}
+}
+
+void
+CShadows::RenderStoredShadows(void)
+{
+	PUSH_RENDERGROUP("CShadows::RenderStoredShadows");
+
+	RenderBuffer::ClearRenderBuffer();
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+
+	for ( int32 i = 0; i < ShadowsStoredToBeRendered; i++ )
+		asShadowsStored[i].m_nFlags.bRendered = false;
+
+	for ( int32 i = 0; i < ShadowsStoredToBeRendered; i++ )
+	{
+		if ( !asShadowsStored[i].m_nFlags.bRendered )
+		{
+			SetRenderModeForShadowType(asShadowsStored[i].m_ShadowType);
+
+			ASSERT(asShadowsStored[i].m_pTexture != NULL);
+
+			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(asShadowsStored[i].m_pTexture));
+
+			for ( int32 j = i; j < ShadowsStoredToBeRendered; j++ )
+			{
+				if ( asShadowsStored[i].m_ShadowType   == asShadowsStored[j].m_ShadowType
+					&& asShadowsStored[i].m_pTexture == asShadowsStored[j].m_pTexture )
+				{
+					float fWidth  = Abs(asShadowsStored[j].m_vecFront.x) + Abs(asShadowsStored[j].m_vecSide.x);
+					float fHeight = Abs(asShadowsStored[j].m_vecFront.y) + Abs(asShadowsStored[j].m_vecSide.y);
+
+					CVector shadowPos = asShadowsStored[j].m_vecPos;
+
+					float fStartX = shadowPos.x - fWidth;
+					float fEndX   = shadowPos.x + fWidth;
+					float fStartY = shadowPos.y - fHeight;
+					float fEndY   = shadowPos.y + fHeight;
+
+					int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
+					int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
+					int32 nEndX   = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X-1);
+					int32 nEndY   = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y-1);
+
+					CWorld::AdvanceCurrentScanCode();
+
+					for ( int32 y = nStartY; y <= nEndY; y++ )
+					{
+						for ( int32 x = nStartX; x <= nEndX; x++ )
+						{
+							CSector *pCurSector = CWorld::GetSector(x, y);
+
+							ASSERT(pCurSector != NULL);
+
+							CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS],
+									fStartX, fStartY,
+									fEndX, fEndY,
+									&shadowPos,
+									asShadowsStored[j].m_vecFront.x,
+									asShadowsStored[j].m_vecFront.y,
+									asShadowsStored[j].m_vecSide.x,
+									asShadowsStored[j].m_vecSide.y,
+									asShadowsStored[j].m_nIntensity,
+									asShadowsStored[j].m_nRed,
+									asShadowsStored[j].m_nGreen,
+									asShadowsStored[j].m_nBlue,
+									asShadowsStored[j].m_fZDistance,
+									asShadowsStored[j].m_fScale,
+									NULL);
+
+							CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP],
+									fStartX, fStartY,
+									fEndX, fEndY,
+									&shadowPos,
+									asShadowsStored[j].m_vecFront.x,
+									asShadowsStored[j].m_vecFront.y,
+									asShadowsStored[j].m_vecSide.x,
+									asShadowsStored[j].m_vecSide.y,
+									asShadowsStored[j].m_nIntensity,
+									asShadowsStored[j].m_nRed,
+									asShadowsStored[j].m_nGreen,
+									asShadowsStored[j].m_nBlue,
+									asShadowsStored[j].m_fZDistance,
+									asShadowsStored[j].m_fScale,
+									NULL);
+						}
+					}
+
+					asShadowsStored[j].m_nFlags.bRendered = true;
+				}
+			}
+
+			RenderBuffer::RenderStuffInBuffer();
+		}
+
+	}
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);
+
+	ShadowsStoredToBeRendered = 0;
+
+	POP_RENDERGROUP();
+}
+
+void
+CShadows::RenderStaticShadows(void)
+{
+	PUSH_RENDERGROUP("CShadows::RenderStaticShadows");
+
+	RenderBuffer::ClearRenderBuffer();
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,         (void *)FALSE);
+
+	SetAlphaTest(0);
+
+	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
+		aStaticShadows[i].m_bRendered = false;
+
+	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
+	{
+		if ( aStaticShadows[i].m_pPolyBunch && !aStaticShadows[i].m_bRendered )
+		{
+			SetRenderModeForShadowType(aStaticShadows[i].m_nType);
+			RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(aStaticShadows[i].m_pTexture));
+
+			// optimization trick, render all shadows with same renderstate and texture
+			for ( int32 j = i; j < MAX_STATICSHADOWS; j++ )
+			{
+				if ( aStaticShadows[j].m_pPolyBunch != NULL
+						&& aStaticShadows[i].m_nType    == aStaticShadows[j].m_nType
+						&& aStaticShadows[i].m_pTexture == aStaticShadows[j].m_pTexture )
+				{
+					for ( CPolyBunch *bunch = aStaticShadows[j].m_pPolyBunch; bunch != NULL; bunch = bunch->m_pNext )
+					{
+						RwImVertexIndex *pIndexes;
+						RwIm3DVertex *pVerts;
+
+						RenderBuffer::StartStoring(3 * (bunch->m_nNumVerts - 2), bunch->m_nNumVerts, &pIndexes, &pVerts);
+
+						ASSERT(pIndexes != NULL);
+						ASSERT(pVerts != NULL);
+
+						for ( int32 k = 0; k < bunch->m_nNumVerts; k++ )
+						{
+							RwIm3DVertexSetRGBA(&pVerts[k],
+									aStaticShadows[j].m_nRed,
+									aStaticShadows[j].m_nGreen,
+									aStaticShadows[j].m_nBlue,
+									(int32)(aStaticShadows[j].m_nIntensity * (1.0f - CWeather::Foggyness * 0.5f)));
+
+							RwIm3DVertexSetU  (&pVerts[k], bunch->m_aU[k] / 200.0f);
+							RwIm3DVertexSetV  (&pVerts[k], bunch->m_aV[k] / 200.0f);
+							RwIm3DVertexSetPos(&pVerts[k], bunch->m_aVerts[k].x, bunch->m_aVerts[k].y,  bunch->m_aVerts[k].z + 0.03f);
+						}
+
+						for ( int32 k = 0; k < 3 * (bunch->m_nNumVerts - 2); k++ )
+							pIndexes[k] = ShadowIndexList[k];
+
+						RenderBuffer::StopStoring();
+					}
+
+					aStaticShadows[j].m_bRendered = true;
+				}
+			}
+
+			RenderBuffer::RenderStuffInBuffer();
+		}
+	}
+	RestoreAlphaTest();
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)TRUE);
+
+	POP_RENDERGROUP();
+}
+
+void
+CShadows::GeneratePolysForStaticShadow(int16 nStaticShadowID)
+{
+	float fWidth  = Abs(aStaticShadows[nStaticShadowID].m_vecFront.x) + Abs(aStaticShadows[nStaticShadowID].m_vecSide.x);
+	float fHeight = Abs(aStaticShadows[nStaticShadowID].m_vecFront.y) + Abs(aStaticShadows[nStaticShadowID].m_vecSide.y);
+
+	CVector shadowPos = aStaticShadows[nStaticShadowID].m_vecPosn;
+
+	float fStartX = shadowPos.x - fWidth;
+	float fEndX   = shadowPos.x + fWidth;
+	float fStartY = shadowPos.y - fHeight;
+	float fEndY   = shadowPos.y + fHeight;
+
+	int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
+	int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
+	int32 nEndX   = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X-1);
+	int32 nEndY   = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y-1);
+
+	CWorld::AdvanceCurrentScanCode();
+
+	for ( int32 y = nStartY; y <= nEndY; y++ )
+	{
+		for ( int32 x = nStartX; x <= nEndX; x++ )
+		{
+			CSector *pCurSector = CWorld::GetSector(x, y);
+
+			ASSERT(pCurSector != NULL);
+
+			CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS],
+					fStartX, fStartY,
+					fEndX, fEndY,
+					&shadowPos,
+					aStaticShadows[nStaticShadowID].m_vecFront.x,
+					aStaticShadows[nStaticShadowID].m_vecFront.y,
+					aStaticShadows[nStaticShadowID].m_vecSide.x,
+					aStaticShadows[nStaticShadowID].m_vecSide.y,
+					0, 0, 0, 0,
+					aStaticShadows[nStaticShadowID].m_fZDistance,
+					aStaticShadows[nStaticShadowID].m_fScale,
+					&aStaticShadows[nStaticShadowID].m_pPolyBunch);
+
+			CastShadowSectorList(pCurSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP],
+					fStartX, fStartY,
+					fEndX, fEndY,
+					&shadowPos,
+					aStaticShadows[nStaticShadowID].m_vecFront.x,
+					aStaticShadows[nStaticShadowID].m_vecFront.y,
+					aStaticShadows[nStaticShadowID].m_vecSide.x,
+					aStaticShadows[nStaticShadowID].m_vecSide.y,
+					0, 0, 0, 0,
+					aStaticShadows[nStaticShadowID].m_fZDistance,
+					aStaticShadows[nStaticShadowID].m_fScale,
+					&aStaticShadows[nStaticShadowID].m_pPolyBunch);
+		}
+	}
+}
+
+void
+CShadows::CastShadowSectorList(CPtrList &PtrList, float fStartX, float fStartY, float fEndX, float fEndY, CVector *pPosn,
+								float fFrontX, float fFrontY, float fSideX, float fSideY,
+								int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
+								float fZDistance, float fScale, CPolyBunch **ppPolyBunch)
+{
+	ASSERT(pPosn != NULL);
+
+	CPtrNode *pNode = PtrList.first;
+
+	CRect Bound;
+
+	while ( pNode != NULL )
+	{
+		CEntity *pEntity = (CEntity *)pNode->item;
+		uint16 nScanCode = pEntity->m_scanCode;
+		pNode = pNode->next;
+
+		ASSERT( pEntity != NULL );
+
+		if ( nScanCode != CWorld::GetCurrentScanCode() )
+		{
+			if ( pEntity->bUsesCollision && pEntity->IsBuilding() )
+			{
+				pEntity->m_scanCode = CWorld::GetCurrentScanCode();
+
+				Bound = pEntity->GetBoundRect();
+
+				if ( fStartX < Bound.right
+					&& fEndX > Bound.left
+					&& fStartY < Bound.bottom
+					&& fEndY > Bound.top )
+				{
+					if ( pPosn->z - fZDistance < pEntity->GetPosition().z + pEntity->GetColModel()->boundingBox.max.z
+						&& pEntity->GetPosition().z + pEntity->GetColModel()->boundingBox.min.z < pPosn->z )
+					{
+						CastShadowEntity(pEntity,
+							fStartX, fStartY,
+							fEndX, fEndY,
+							pPosn,
+							fFrontX, fFrontY,
+							fSideX, fSideY,
+							nIntensity, nRed, nGreen, nBlue,
+							fZDistance, fScale, ppPolyBunch);
+					}
+				}
+			}
+		}
+	}
+}
+
+void
+CShadows::CastShadowEntity(CEntity *pEntity,  float fStartX, float fStartY, float fEndX, float fEndY, CVector *pPosn,
+							float fFrontX, float fFrontY, float fSideX, float fSideY,
+							int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue,
+							float fZDistance, float fScale, CPolyBunch **ppPolyBunch)
+{	
+	ASSERT(pEntity != NULL);
+	ASSERT(pPosn != NULL);
+
+	static CVector List   [20];
+	static CVector Texture[20];
+	static CVector Points [4];
+
+	CColModel *pCol = pEntity->GetColModel();
+	ASSERT(pCol != NULL);
+
+#ifndef MASTER
+	if ( gbPrintShite )
+		printf("MI:%d Triangles:%d Coors:%f %f BBoxXY:%f %f\n",
+			pEntity->GetModelIndex(),
+			pCol->numTriangles,
+			pEntity->GetPosition().x,
+			pEntity->GetPosition().y,
+			pCol->boundingBox.GetSize().x,
+			pCol->boundingBox.GetSize().y);
+#endif
+	
+	CCollision::CalculateTrianglePlanes(pCol);
+
+	float fFrontRight    = DotProduct2D(CVector2D(fFrontX, fFrontY),     pEntity->GetRight());
+	float fFrontForward  = DotProduct2D(CVector2D(fFrontX, fFrontY),     pEntity->GetForward());
+	float fSideRight     = DotProduct2D(CVector2D(fSideX, fSideY),       pEntity->GetRight());
+	float fSideForward   = DotProduct2D(CVector2D(fSideX, fSideY),       pEntity->GetForward());
+	float fLengthRight   = DotProduct2D(*pPosn - pEntity->GetPosition(), pEntity->GetRight());
+	float fLengthForward = DotProduct2D(*pPosn - pEntity->GetPosition(), pEntity->GetForward());
+
+	Points[0].x = (fLengthRight   + fFrontRight  )  - fSideRight;
+	Points[0].y = (fLengthForward + fFrontForward)  - fSideForward;
+
+	Points[1].x = fSideRight      + (fLengthRight   + fFrontRight);
+	Points[1].y = fSideForward    + (fLengthForward + fFrontForward);
+                                  
+	Points[2].x = fSideRight      + (fLengthRight   - fFrontRight);
+	Points[2].y = fSideForward    + (fLengthForward - fFrontForward);
+
+	Points[3].x = (fLengthRight   - fFrontRight)    - fSideRight;
+	Points[3].y = (fLengthForward - fFrontForward)  - fSideForward;
+
+	float MinX = Min(Min(Points[0].x, Points[1].x), Min(Points[2].x, Points[3].x));
+	float MaxX = Max(Max(Points[0].x, Points[1].x), Max(Points[2].x, Points[3].x));
+
+	float MinY = Min(Min(Points[0].y, Points[1].y), Min(Points[2].y, Points[3].y));
+	float MaxY = Max(Max(Points[0].y, Points[1].y), Max(Points[2].y, Points[3].y));
+
+	float MaxZ = pPosn->z - pEntity->GetPosition().z;
+	float MinZ = MaxZ - fZDistance;
+
+	for ( int32 i = 0; i < pCol->numTriangles; i++ )
+	{
+		CColTrianglePlane *pColTriPlanes = pCol->trianglePlanes;
+		ASSERT(pColTriPlanes != NULL);
+
+		CVector normal;
+		pColTriPlanes[i].GetNormal(normal);
+		if ( Abs(normal.z) > 0.1f )
+		{
+			CColTriangle *pColTri = pCol->triangles;
+			ASSERT(pColTri != NULL);
+
+			CVector PointA, PointB, PointC;
+
+			pCol->GetTrianglePoint(PointA, pColTri[i].a);
+			pCol->GetTrianglePoint(PointB, pColTri[i].b);
+			pCol->GetTrianglePoint(PointC, pColTri[i].c);
+
+			if (   (PointA.x > MinX || PointB.x > MinX || PointC.x > MinX)
+				&& (PointA.x < MaxX || PointB.x < MaxX || PointC.x < MaxX)
+				&& (PointA.y > MinY || PointB.y > MinY || PointC.y > MinY)
+				&& (PointA.y < MaxY || PointB.y < MaxY || PointC.y < MaxY)
+				&& (PointA.z < MaxZ || PointB.z < MaxZ || PointC.z < MaxZ)
+				&& (PointA.z > MinZ || PointB.z > MinZ || PointC.z > MinZ) )
+
+			{
+				List[0].x = Points[0].x;
+				List[0].y = Points[0].y;
+
+				List[1].x = Points[1].x;
+				List[1].y = Points[1].y;
+
+				List[2].x = Points[2].x;
+				List[2].y = Points[2].y;
+
+				List[3].x = Points[3].x;
+				List[3].y = Points[3].y;
+
+				Texture[0].x = 0.0f;
+				Texture[0].y = 0.0f;
+
+				Texture[1].x = 1.0f;
+				Texture[1].y = 0.0f;
+
+				Texture[2].x = 1.0f;
+				Texture[2].y = 1.0f;
+
+				Texture[3].x = 0.0f;
+				Texture[3].y = 1.0f;
+
+
+				CVector2D start;
+				CVector2D dist;
+
+				int32 numVerts1 = 0;
+				int16 vertType1 = 0;
+				{						
+					for ( int32 j = 0; j < 4; j++ )
+					{
+						start = PointA;
+						dist  = PointB - PointA;
+						
+						int32 in = j;
+						
+						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);
+
+						if ( cp > 0.0f )
+						{
+							switch ( vertType1 )
+							{
+								case 0:
+								{
+									int32 out = numVerts1++ + 10;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+
+									break;
+								}
+
+								case 1:
+								{
+									int32 out = numVerts1++ + 10;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+
+									break;
+								}
+
+								case 2:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out1 = numVerts1++ + 10;
+									int32 out2 = numVerts1++ + 10;
+
+									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;
+
+									Texture[out2].x = Texture[in].x;
+									Texture[out2].y = Texture[in].y;
+									List[out2].x    = List[in].x;
+									List[out2].y    = List[in].y;
+
+									break;
+								}
+							}
+
+							vertType1 = 1;
+						}
+						else
+						{
+							switch ( vertType1 )
+							{
+								case 1:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out = numVerts1++ + 10;
+
+									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
+									
+									break;
+								}
+							}
+
+							vertType1 = 2;
+						}
+					}
+
+					float cp1 = CrossProduct2D(CVector2D(List[0]) - start, dist);
+					if ( cp1 > 0.0f && vertType1 == 2 || cp1 <= 0.0f && vertType1 == 1 )
+					{
+						float cp2 = CrossProduct2D(CVector2D(List[3]) - start, dist);
+
+						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
+						float Compl = 1.0f - Scale;
+
+						int32 out = numVerts1++ + 10;
+
+						Texture[out].x = Compl*Texture[3].x + Scale*Texture[0].x;
+						Texture[out].y = Compl*Texture[3].y + Scale*Texture[0].y;
+						List[out].x    = Compl*List[3].x    + Scale*List[0].x;
+						List[out].y    = Compl*List[3].y    + Scale*List[0].y;
+					}
+				}
+
+				int32 numVerts2 = 0;
+				int16 vertType2 = 0;
+				{						
+					for ( int32 j = 0; j < numVerts1; j++ )
+					{
+						start = PointB;
+						dist  = PointC - PointB;
+					
+						int32 in = j + 10;
+						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);
+
+						if ( cp > 0.0f )
+						{
+							switch ( vertType2 )
+							{
+								case 0:
+								{
+									int32 out = numVerts2++;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+									
+									break;
+								}
+
+								case 1:
+								{
+									int32 out = numVerts2++;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+									
+									break;
+								}
+
+								case 2:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out1 = numVerts2++;
+									int32 out2 = numVerts2++;
+
+									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;
+
+									Texture[out2].x = Texture[in].x;
+									Texture[out2].y = Texture[in].y;
+									List[out2].x    = List[in].x;
+									List[out2].y    = List[in].y;
+									
+									break;
+								}
+							}
+
+							vertType2 = 1;
+						}
+						else
+						{
+							switch ( vertType2 )
+							{
+								case 1:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out = numVerts2++;
+
+									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
+									
+									break;
+								}
+							}
+
+							vertType2 = 2;
+						}
+					}
+
+					float cp1 = CrossProduct2D(CVector2D(List[10]) - start, dist);
+					if ( cp1 > 0.0f && vertType2 == 2 || cp1 <= 0.0f && vertType2 == 1 )
+					{
+						int32 in = numVerts1 + 10;
+
+						float cp2 = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
+						float Compl = 1.0f - Scale;
+
+						int32 out = numVerts2++;
+
+						Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[10].x;
+						Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[10].y;
+						List[out].x    = Compl*List[in-1].x    + Scale*List[10].x;
+						List[out].y    = Compl*List[in-1].y    + Scale*List[10].y;
+					}
+				}
+
+				int32 numVerts3 = 0;
+				int16 vertType3 = 0;
+				{					
+					for ( int32 j = 0; j < numVerts2; j++ )
+					{
+						start = PointC;
+						dist  = PointA - PointC;
+					
+						int32 in = j;
+						float cp = CrossProduct2D(CVector2D(List[in]) - start, dist);
+
+						if ( cp > 0.0f )
+						{
+							switch ( vertType3 )
+							{
+								case 0:
+								{
+									int32 out = numVerts3++ + 10;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+									
+									break;
+								}
+
+								case 1:
+								{
+									int32 out = numVerts3++ + 10;
+
+									Texture[out].x = Texture[in].x;
+									Texture[out].y = Texture[in].y;
+									List[out].x    = List[in].x;
+									List[out].y    = List[in].y;
+									
+									break;
+								}
+
+								case 2:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out1 = numVerts3++ + 10;
+									int32 out2 = numVerts3++ + 10;
+
+									Texture[out1].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out1].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out1].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out1].y    = Compl*List[in-1].y    + Scale*List[in].y;
+
+									Texture[out2].x = Texture[in].x;
+									Texture[out2].y = Texture[in].y;
+									List[out2].x    = List[in].x;
+									List[out2].y    = List[in].y;
+									
+									break;
+								}
+							}
+
+							vertType3 = 1;
+						}
+						else
+						{
+							switch ( vertType3 )
+							{
+								case 1:
+								{
+									float prevcp = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+									float Scale = Abs(prevcp) / (Abs(prevcp) + Abs(cp));
+									float Compl = 1.0f - Scale;
+
+									int32 out = numVerts3++ + 10;
+
+									Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[in].x;
+									Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[in].y;
+									List[out].x    = Compl*List[in-1].x    + Scale*List[in].x;
+									List[out].y    = Compl*List[in-1].y    + Scale*List[in].y;
+									
+									break;
+								}
+							}
+
+							vertType3 = 2;
+						}
+					}
+
+					float cp1 = CrossProduct2D(CVector2D(List[0]) - start, dist);
+					if ( cp1 > 0.0f && vertType3 == 2 || cp1 <= 0.0f && vertType3 == 1 )
+					{
+						int32 in = numVerts2;
+
+						float cp2 = CrossProduct2D(CVector2D(List[in-1]) - start, dist);
+
+						float Scale = Abs(cp2) / (Abs(cp2) + Abs(cp1));
+						float Compl = 1.0f - Scale;
+
+						int32 out = numVerts3++ + 10;
+
+						Texture[out].x = Compl*Texture[in-1].x + Scale*Texture[0].x;
+						Texture[out].y = Compl*Texture[in-1].y + Scale*Texture[0].y;
+						List[out].x    = Compl*List[in-1].x    + Scale*List[0].x;
+						List[out].y    = Compl*List[in-1].y    + Scale*List[0].y;
+					}
+				}
+					
+				if ( numVerts3 >= 3 )
+				{
+					CVector norm;
+
+					pColTriPlanes[i].GetNormal(norm);
+
+					float dot = DotProduct(norm, PointA);
+
+					for ( int32 j = 0; j < numVerts3; j++ )
+					{
+						int32 idx = j + 10;
+
+						List[idx].z = -(DotProduct2D(norm, List[idx]) - dot) / norm.z;
+					}
+
+					for ( int32 j = 0; j < numVerts3; j++ )
+					{
+						int32 idx = j + 10;
+
+						CVector p = List[idx];
+						
+						List[idx].x = p.y * pEntity->GetForward().x + p.x * pEntity->GetRight().x + pEntity->GetPosition().x;
+						List[idx].y = p.y * pEntity->GetForward().y + p.x * pEntity->GetRight().y + pEntity->GetPosition().y;
+						List[idx].z = p.z + pEntity->GetPosition().z;
+					}
+
+					
+					if ( ppPolyBunch != NULL )
+					{
+						if ( pEmptyBunchList != NULL )
+						{
+							CPolyBunch *pBunch = pEmptyBunchList;
+							ASSERT(pBunch != NULL);
+							pEmptyBunchList = pEmptyBunchList->m_pNext;
+							pBunch->m_pNext = *ppPolyBunch;
+							*ppPolyBunch = pBunch;
+	
+							pBunch->m_nNumVerts = numVerts3;
+	
+							for ( int32 j = 0; j < numVerts3; j++ )
+							{
+								int32 in = j + 10;
+	
+								pBunch->m_aVerts[j] = List[in];
+	
+								pBunch->m_aU[j] = (int32)(Texture[in].x * 200.0f);
+								pBunch->m_aV[j] = (int32)(Texture[in].y * 200.0f);
+							}
+						}
+					}
+					else
+					{
+						RwImVertexIndex *pIndexes;
+						RwIm3DVertex *pVerts;
+
+						RenderBuffer::StartStoring(3 * (numVerts3 - 2), numVerts3, &pIndexes, &pVerts);
+
+						ASSERT(pIndexes != NULL);
+						ASSERT(pVerts != NULL);
+
+
+						for ( int32 j = 0; j < numVerts3; j++ )
+						{
+							int32 in = j + 10;
+
+							RwIm3DVertexSetRGBA(&pVerts[j], nRed, nGreen, nBlue, nIntensity);
+							RwIm3DVertexSetU   (&pVerts[j], Texture[in].x*fScale);
+							RwIm3DVertexSetV   (&pVerts[j], Texture[in].y*fScale);
+							RwIm3DVertexSetPos (&pVerts[j], List[in].x, List[in].y, List[in].z + 0.03f);
+						}
+
+						for ( int32 j = 0; j < 3*(numVerts3 - 2); j++ )
+							pIndexes[j] = ShadowIndexList[j];
+
+						RenderBuffer::StopStoring();
+					}
+				}
+			}
+		}
+	}
+}
+
+void
+CShadows::UpdateStaticShadows(void)
+{
+	for ( int32 i = 0; i < MAX_STATICSHADOWS; i++ )
+	{
+		if ( aStaticShadows[i].m_pPolyBunch != NULL && !aStaticShadows[i].m_bJustCreated
+			&& (!aStaticShadows[i].m_bTemp || CTimer::GetTimeInMilliseconds() > aStaticShadows[i].m_nTimeCreated + 5000) )
+		{
+			aStaticShadows[i].Free();
+		}
+
+		aStaticShadows[i].m_bJustCreated = false;
+	}
+}
+
+void
+CShadows::UpdatePermanentShadows(void)
+{
+	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
+	{
+		if ( aPermanentShadows[i].m_nType != SHADOWTYPE_NONE )
+		{
+			uint32 timePassed = CTimer::GetTimeInMilliseconds() - aPermanentShadows[i].m_nTimeCreated;
+
+			if ( timePassed >= aPermanentShadows[i].m_nLifeTime )
+				aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
+			else
+			{
+				if ( timePassed >= (aPermanentShadows[i].m_nLifeTime * 3 / 4) )
+				{
+					// timePassed == 0                                -> 4
+					// timePassed == aPermanentShadows[i].m_nLifeTime -> 0
+					float fMult = 1.0f - float(timePassed - (aPermanentShadows[i].m_nLifeTime * 3 / 4)) / (aPermanentShadows[i].m_nLifeTime / 4);
+
+					StoreStaticShadow((uintptr)&aPermanentShadows[i],
+						aPermanentShadows[i].m_nType,
+						aPermanentShadows[i].m_pTexture,
+						&aPermanentShadows[i].m_vecPos,
+						aPermanentShadows[i].m_vecFront.x,
+						aPermanentShadows[i].m_vecFront.y,
+						aPermanentShadows[i].m_vecSide.x,
+						aPermanentShadows[i].m_vecSide.y,
+						(int32)(aPermanentShadows[i].m_nIntensity * fMult),
+						(int32)(aPermanentShadows[i].m_nRed       * fMult),
+						(int32)(aPermanentShadows[i].m_nGreen     * fMult),
+						(int32)(aPermanentShadows[i].m_nBlue      * fMult),
+						aPermanentShadows[i].m_fZDistance,
+						1.0f, 40.0f, false, 0.0f);
+				}
+				else
+				{
+					StoreStaticShadow((uintptr)&aPermanentShadows[i],
+						aPermanentShadows[i].m_nType,
+						aPermanentShadows[i].m_pTexture,
+						&aPermanentShadows[i].m_vecPos,
+						aPermanentShadows[i].m_vecFront.x,
+						aPermanentShadows[i].m_vecFront.y,
+						aPermanentShadows[i].m_vecSide.x,
+						aPermanentShadows[i].m_vecSide.y,
+						aPermanentShadows[i].m_nIntensity,
+						aPermanentShadows[i].m_nRed,
+						aPermanentShadows[i].m_nGreen,
+						aPermanentShadows[i].m_nBlue,
+						aPermanentShadows[i].m_fZDistance,
+						1.0f, 40.0f, false, 0.0f);
+				}
+			}
+		}
+	}
+}
+
+void
+CStaticShadow::Free(void)
+{
+	if ( m_pPolyBunch != NULL )
+	{
+		CPolyBunch *pFree = CShadows::pEmptyBunchList;
+		CShadows::pEmptyBunchList = m_pPolyBunch;
+
+		CPolyBunch *pUsed = m_pPolyBunch;
+		while (pUsed->m_pNext != NULL)
+			pUsed = pUsed->m_pNext;
+
+			pUsed->m_pNext = pFree;
+	}
+
+	m_pPolyBunch = NULL;
+
+	m_nId = 0;
+}
+
+void
+CShadows::CalcPedShadowValues(CVector vecLightDir,
+							float *pfFrontX, float *pfFrontY,
+							float *pfSideX, float *pfSideY,
+							float *pfDisplacementX, float *pfDisplacementY)
+{
+	ASSERT(pfFrontX != nil);
+	ASSERT(pfFrontY != nil);
+	ASSERT(pfSideX != nil);
+	ASSERT(pfSideY != nil);
+	ASSERT(pfDisplacementX != nil);
+	ASSERT(pfDisplacementY != nil);
+
+	*pfFrontX = -vecLightDir.x;
+	*pfFrontY = -vecLightDir.y;
+
+	float fDist = Sqrt(*pfFrontY * *pfFrontY + *pfFrontX * *pfFrontX);
+	float fMult = (fDist + 1.0f) / fDist;
+
+	*pfFrontX *= fMult;
+	*pfFrontY *= fMult;
+
+	*pfSideX = -vecLightDir.y / fDist;
+	*pfSideY =  vecLightDir.x / fDist;
+
+	*pfDisplacementX = -vecLightDir.x;
+	*pfDisplacementY = -vecLightDir.y;
+
+	*pfFrontX /= 2;
+	*pfFrontY /= 2;
+
+	*pfSideX /= 2;
+	*pfSideY /= 2;
+
+	*pfDisplacementX /= 2;
+	*pfDisplacementY /= 2;
+	
+}
+
+void
+CShadows::RenderExtraPlayerShadows(void)
+{
+#ifdef FIX_BUGS
+	if (CReplay::IsPlayingBack())
+		return;
+#endif
+	if ( CTimeCycle::GetLightShadowStrength() != 0 )
+	{
+		CVehicle *pCar = FindPlayerVehicle();
+
+		if ( pCar == NULL )
+		{
+			for ( int32 i = 0; i < CPointLights::NumLights; i++ )
+			{
+				if (   0.0f != CPointLights::aLights[i].red
+					|| 0.0f != CPointLights::aLights[i].green
+					|| 0.0f != CPointLights::aLights[i].blue )
+				{
+					if ( CPointLights::aLights[i].castExtraShadows )
+					{
+						CVector vecLight = CPointLights::aLights[i].coors - FindPlayerCoors();
+						float fLightDist = vecLight.Magnitude();
+						float fRadius = CPointLights::aLights[i].radius;
+
+						if ( fLightDist < fRadius )
+						{
+							// fLightDist == fRadius -> 2.0f
+							// fLightDist == 0       -> 0.0f
+							float fMult = (1.0f - (2.0f * fLightDist - fRadius) / fRadius);
+
+							int32 nColorStrength;
+							if ( fLightDist < fRadius*0.5f )
+								nColorStrength = (5*CTimeCycle::GetLightShadowStrength()/8);
+							else
+								nColorStrength = int32((5*CTimeCycle::GetLightShadowStrength()/8) * fMult);
+
+							float fInv = 1.0f / fLightDist;
+							vecLight.x *= fInv;
+							vecLight.y *= fInv;
+							vecLight.z *= fInv;
+
+							float fFrontX, fFrontY, fSideX, fSideY, fDisplacementX, fDisplacementY;
+
+							CalcPedShadowValues(vecLight,
+												&fFrontX, &fFrontY,
+												&fSideX, &fSideY,
+												&fDisplacementX, &fDisplacementY);
+
+							CVector shadowPos = FindPlayerCoors();
+
+							shadowPos.x += fDisplacementX;
+							shadowPos.y += fDisplacementY;
+
+
+							StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowPedTex, &shadowPos,
+									fFrontX, fFrontY,
+									fSideX, fSideY,
+									nColorStrength, 0, 0, 0,
+									4.0f, false, 1.0f);
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			if ( pCar->GetModelIndex() != MI_RCBANDIT )
+			{
+				for ( int32 i = 0; i < CPointLights::NumLights; i++ )
+				{
+					if (  CPointLights::aLights[i].type == CPointLights::LIGHT_POINT
+						&& CPointLights::aLights[i].castExtraShadows
+						&&(0.0f != CPointLights::aLights[i].red
+						|| 0.0f != CPointLights::aLights[i].green
+						|| 0.0f != CPointLights::aLights[i].blue) )
+					{
+						CVector vecLight = CPointLights::aLights[i].coors - FindPlayerCoors();
+						float fLightDist = vecLight.Magnitude();
+						float fRadius = CPointLights::aLights[i].radius;
+
+						if ( fLightDist < fRadius )
+						{
+							// fLightDist == 0       -> 2.0f
+							// fLightDist == fRadius -> 0.0f
+							float fMult = (1.0f - (2.0f * fLightDist - fRadius) / fRadius);
+
+							int32 nColorStrength;
+							if ( fLightDist < fRadius*0.5f )
+								nColorStrength = (5*CTimeCycle::GetLightShadowStrength()/8);
+							else
+								nColorStrength = int32((5*CTimeCycle::GetLightShadowStrength()/8) * fMult);
+
+							float fInv = 1.0f / fLightDist;
+							vecLight.x *= fInv;
+							vecLight.y *= fInv;
+							vecLight.z *= fInv;
+
+							CVector shadowPos = pCar->GetPosition();
+
+							shadowPos.x -= vecLight.x * 1.2f;
+							shadowPos.y -= vecLight.y * 1.2f;
+
+							float fVehicleWidth   = pCar->GetColModel()->boundingBox.GetSize().x;
+							float fVehicleHeight  = pCar->GetColModel()->boundingBox.GetSize().y;
+
+							shadowPos.x -= ((fVehicleHeight/2) - pCar->GetColModel()->boundingBox.max.y)
+											* pCar->GetForward().x;
+
+							shadowPos.y -= ((fVehicleHeight/2) - pCar->GetColModel()->boundingBox.max.y)
+											* pCar->GetForward().y;
+
+							if ( pCar->GetUp().z > 0.0f )
+							{
+								StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &shadowPos,
+									pCar->GetForward().x * (fVehicleHeight/2),
+									pCar->GetForward().y * (fVehicleHeight/2),
+									pCar->GetRight().x   * (fVehicleWidth/3),
+									pCar->GetRight().y   * (fVehicleWidth/3),
+									nColorStrength, 0, 0, 0,
+									4.5f, false, 1.0f);
+							}
+							else
+							{
+								StoreShadowToBeRendered(SHADOWTYPE_DARK, gpShadowCarTex, &shadowPos,
+									pCar->GetForward().x * (fVehicleHeight/2),
+									pCar->GetForward().y * (fVehicleHeight/2),
+									-pCar->GetRight().x  * (fVehicleWidth/2),
+									-pCar->GetRight().y  * (fVehicleWidth/2),
+									nColorStrength, 0, 0, 0,
+									4.5f, false, 1.0f);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void
+CShadows::TidyUpShadows(void)
+{
+	for ( int32 i = 0; i < MAX_PERMAMENTSHADOWS; i++ )
+		aPermanentShadows[i].m_nType = SHADOWTYPE_NONE;
+}
+
+void
+CShadows::RenderIndicatorShadow(uint32 nID, uint8 ShadowType, RwTexture *pTexture,  CVector *pPosn,
+								float fFrontX, float fFrontY, float fSideX, float fSideY,
+								int16 nIntensity)
+{
+	ASSERT(pPosn != NULL);
+
+	C3dMarkers::PlaceMarkerSet(nID, MARKERTYPE_CYLINDER, *pPosn, Max(fFrontX, -fSideY),
+			0, 128, 255, 128,
+			2048, 0.2f, 0);
+}
diff --git a/src/renderer/Shadows.h b/src/renderer/Shadows.h
new file mode 100644
index 00000000..8c909df3
--- /dev/null
+++ b/src/renderer/Shadows.h
@@ -0,0 +1,180 @@
+#pragma once
+
+#define MAX_STOREDSHADOWS    48
+#define MAX_POLYBUNCHES      300
+#define MAX_STATICSHADOWS    64
+#define MAX_PERMAMENTSHADOWS 48
+
+
+class CEntity;
+
+enum eShadowType
+{
+	SHADOWTYPE_NONE = 0,
+	SHADOWTYPE_DARK,
+	SHADOWTYPE_ADDITIVE,
+	SHADOWTYPE_INVCOLOR
+};
+
+enum eShadowTextureType
+{
+    SHADOWTEX_NONE = 0,
+    SHADOWTEX_CAR,
+    SHADOWTEX_PED,
+    SHADOWTEX_EXPLOSION,
+    SHADOWTEX_HELI,
+    SHADOWTEX_HEADLIGHTS,
+    SHADOWTEX_BLOOD
+};
+
+class CStoredShadow
+{
+public:
+	CVector m_vecPos;
+	CVector2D m_vecFront;
+	CVector2D m_vecSide;
+	float m_fZDistance;
+	float m_fScale;
+	int16 m_nIntensity;
+	uint8 m_ShadowType;
+	uint8 m_nRed;
+	uint8 m_nGreen;
+	uint8 m_nBlue;
+	struct
+	{
+		uint8 bDrawOnWater      : 1;
+		uint8 bRendered         : 1;
+		//uint8 bDrawOnBuildings  : 1;
+	} m_nFlags;
+	RwTexture *m_pTexture;
+
+    CStoredShadow()
+	{  }
+};
+
+VALIDATE_SIZE(CStoredShadow, 0x30);
+
+class CPolyBunch
+{
+public:
+	int16 m_nNumVerts;
+	CVector m_aVerts[7];
+	uint8 m_aU[7];
+	uint8 m_aV[7];
+	CPolyBunch *m_pNext;
+
+    CPolyBunch()
+	{  }
+};
+
+VALIDATE_SIZE(CPolyBunch, 0x6C);
+
+class CStaticShadow
+{
+public:
+	uint32 m_nId;
+	CPolyBunch *m_pPolyBunch;
+	uint32 m_nTimeCreated;
+	CVector m_vecPosn;
+	CVector2D m_vecFront;
+	CVector2D m_vecSide;
+	float m_fZDistance;
+	float m_fScale;
+	uint8 m_nType;
+	int16 m_nIntensity; // unsigned ?
+	uint8 m_nRed;
+	uint8 m_nGreen;
+	uint8 m_nBlue;
+	bool m_bJustCreated;
+	bool m_bRendered;
+	bool m_bTemp;
+	RwTexture *m_pTexture;
+
+	CStaticShadow()
+	{  }
+
+	void Free();
+};
+
+VALIDATE_SIZE(CStaticShadow, 0x40);
+
+class CPermanentShadow
+{
+public:
+	CVector m_vecPos;
+	CVector2D m_vecFront;
+	CVector2D m_vecSide;
+	float m_fZDistance;
+	float m_fScale;
+	int16 m_nIntensity;
+	uint8 m_nType;	// eShadowType
+	uint8 m_nRed;
+	uint8 m_nGreen;
+	uint8 m_nBlue;
+	uint32 m_nTimeCreated;
+	uint32 m_nLifeTime;
+	RwTexture *m_pTexture;
+
+	CPermanentShadow()
+	{  }
+};
+
+VALIDATE_SIZE(CPermanentShadow, 0x38);
+
+class CPtrList;
+class CAutomobile;
+class CPed;
+
+class CShadows
+{
+public:
+	static int16            ShadowsStoredToBeRendered;
+	static CStoredShadow    asShadowsStored  [MAX_STOREDSHADOWS];
+	static CPolyBunch       aPolyBunches     [MAX_POLYBUNCHES];
+	static CStaticShadow    aStaticShadows   [MAX_STATICSHADOWS];
+	static CPolyBunch      *pEmptyBunchList;
+	static CPermanentShadow aPermanentShadows[MAX_PERMAMENTSHADOWS];
+
+	static void Init                         (void);
+	static void Shutdown                     (void);
+	static void AddPermanentShadow           (            uint8 ShadowType, RwTexture *pTexture, CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue, float fZDistance, uint32 nTime, float fScale);
+	static void StoreStaticShadow            (uint32 nID, uint8 ShadowType, RwTexture *pTexture, Const CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue, float fZDistance,               float fScale, float fDrawDistance, bool bTempShadow, float fUpDistance);
+	static void StoreShadowToBeRendered      (            uint8 ShadowType,                      CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue);
+	static void StoreShadowToBeRendered      (            uint8 ShadowType, RwTexture *pTexture, CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue, float fZDistance, bool bDrawOnWater, float fScale);
+	static void StoreShadowForCar            (CAutomobile *pCar);
+	static void StoreCarLightShadow          (CAutomobile *pCar, int32 nID, RwTexture *pTexture, CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY,                   uint8 nRed, uint8 nGreen, uint8 nBlue, float fMaxViewAngle);
+	static void StoreShadowForPed            (CPed        *pPed,     float fDisplacementX, float fDisplacementY, float fFrontX, float fFrontY, float fSideX, float fSideY);
+	static void StoreShadowForPedObject      (CEntity *pPedObject,   float fDisplacementX, float fDisplacementY, float fFrontX, float fFrontY, float fSideX, float fSideY);
+	static void StoreShadowForTree           (CEntity *pTree);
+	static void StoreShadowForPole           (CEntity *pPole, float fOffsetX, float fOffsetY, float fOffsetZ, float fPoleHeight, float fPoleWidth, uint32 nID);
+	static void SetRenderModeForShadowType   (uint8 ShadowType);
+	static void RenderStoredShadows          (void);
+	static void RenderStaticShadows          (void);
+	static void GeneratePolysForStaticShadow (int16 nStaticShadowID);
+	static void CastShadowSectorList         (CPtrList &PtrList, float fStartX, float fStartY, float fEndX, float fEndY,
+																							     CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue, float fZDistance,               float fScale, CPolyBunch **ppPolyBunch);
+	static void CastShadowEntity             (CEntity *pEntity,  float fStartX, float fStartY, float fEndX, float fEndY,
+																							     CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity, uint8 nRed, uint8 nGreen, uint8 nBlue, float fZDistance,               float fScale, CPolyBunch **ppPolyBunch);
+	static void UpdateStaticShadows          (void);
+	static void UpdatePermanentShadows       (void);
+	static void CalcPedShadowValues            (CVector vecLightDir, float *pfFrontX, float *pfFrontY, float *pfSideX, float *pfSideY, float *pfDisplacementX, float *pfDisplacementY);
+	static void RenderExtraPlayerShadows     (void);
+	static void TidyUpShadows                (void);
+	static void RenderIndicatorShadow        (uint32 nID, uint8 ShadowType, RwTexture *pTexture,  CVector *pPosn, float fFrontX, float fFrontY, float fSideX, float fSideY, int16 nIntensity);
+};
+
+extern RwTexture *gpShadowCarTex;
+extern RwTexture *gpShadowPedTex;
+extern RwTexture *gpShadowHeliTex;
+extern RwTexture *gpShadowExplosionTex;
+extern RwTexture *gpShadowHeadLightsTex;
+extern RwTexture *gpOutline1Tex;
+extern RwTexture *gpOutline2Tex;
+extern RwTexture *gpOutline3Tex;
+extern RwTexture *gpBloodPoolTex;
+extern RwTexture *gpReflectionTex;
+extern RwTexture *gpGoalMarkerTex;
+extern RwTexture *gpWalkDontTex;
+extern RwTexture *gpCrackedGlassTex;
+extern RwTexture *gpPostShadowTex;
+extern RwTexture *gpGoalTex;
diff --git a/src/renderer/Skidmarks.cpp b/src/renderer/Skidmarks.cpp
new file mode 100644
index 00000000..4c662a79
--- /dev/null
+++ b/src/renderer/Skidmarks.cpp
@@ -0,0 +1,262 @@
+#include "common.h"
+
+#include "main.h"
+#include "TxdStore.h"
+#include "Timer.h"
+#include "Replay.h"
+#include "Skidmarks.h"
+
+CSkidmark CSkidmarks::aSkidmarks[NUMSKIDMARKS];
+
+RwImVertexIndex SkidmarkIndexList[SKIDMARK_LENGTH * 6];
+RwIm3DVertex SkidmarkVertices[SKIDMARK_LENGTH * 2];
+RwTexture *gpSkidTex;
+RwTexture *gpSkidBloodTex;
+RwTexture *gpSkidMudTex;
+
+void
+CSkidmarks::Init(void)
+{
+	int i, ix, slot;
+	CTxdStore::PushCurrentTxd();
+	slot = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::SetCurrentTxd(slot);
+	gpSkidTex = RwTextureRead("particleskid", nil);
+	gpSkidBloodTex = RwTextureRead("particleskidblood", nil);
+	gpSkidMudTex = RwTextureRead("particleskidmud", nil);
+	CTxdStore::PopCurrentTxd();
+
+	for(i = 0; i < NUMSKIDMARKS; i++){
+		aSkidmarks[i].m_state = 0;
+		aSkidmarks[i].m_wasUpdated = false;
+	}
+
+	ix = 0;
+	for(i = 0; i < SKIDMARK_LENGTH; i++){
+		SkidmarkIndexList[i*6+0] = ix+0;
+		SkidmarkIndexList[i*6+1] = ix+2;
+		SkidmarkIndexList[i*6+2] = ix+1;
+		SkidmarkIndexList[i*6+3] = ix+1;
+		SkidmarkIndexList[i*6+4] = ix+2;
+		SkidmarkIndexList[i*6+5] = ix+3;
+		ix += 2;
+	}
+
+	for(i = 0; i < SKIDMARK_LENGTH; i++){
+		RwIm3DVertexSetU(&SkidmarkVertices[i*2 + 0], 0.0f);
+		RwIm3DVertexSetV(&SkidmarkVertices[i*2 + 0], i*5.01f);
+		RwIm3DVertexSetU(&SkidmarkVertices[i*2 + 1], 1.0f);
+		RwIm3DVertexSetV(&SkidmarkVertices[i*2 + 1], i*5.01f);
+	}
+}
+
+void
+CSkidmarks::Shutdown(void)
+{
+	RwTextureDestroy(gpSkidTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpSkidTex = nil;
+#endif
+	RwTextureDestroy(gpSkidBloodTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpSkidBloodTex = nil;
+#endif
+	RwTextureDestroy(gpSkidMudTex);
+#if GTA_VERSION >= GTA3_PC_11
+	gpSkidMudTex = nil;
+#endif
+}
+
+void
+CSkidmarks::Clear(void)
+{
+	int i;
+	for(i = 0; i < NUMSKIDMARKS; i++){
+		aSkidmarks[i].m_state = 0;
+		aSkidmarks[i].m_wasUpdated = false;
+	}
+}
+
+void
+CSkidmarks::Update(void)
+{
+	int i;
+	uint32 t1 = CTimer::GetTimeInMilliseconds() + 2500;
+	uint32 t2 = CTimer::GetTimeInMilliseconds() + 5000;
+	uint32 t3 = CTimer::GetTimeInMilliseconds() + 10000;
+	uint32 t4 = CTimer::GetTimeInMilliseconds() + 20000;
+	for(i = 0; i < NUMSKIDMARKS; i++){
+		switch(aSkidmarks[i].m_state){
+		case 1:
+			if(!aSkidmarks[i].m_wasUpdated){
+				// Didn't continue this one last time, so finish it and set fade times
+				aSkidmarks[i].m_state = 2;
+				if(aSkidmarks[i].m_last < 4){
+					aSkidmarks[i].m_fadeStart = t1;
+					aSkidmarks[i].m_fadeEnd = t2;
+				}else if(aSkidmarks[i].m_last < 9){
+					aSkidmarks[i].m_fadeStart = t2;
+					aSkidmarks[i].m_fadeEnd = t3;
+				}else{
+					aSkidmarks[i].m_fadeStart = t3;
+					aSkidmarks[i].m_fadeEnd = t4;
+				}
+			}
+			break;
+		case 2:
+			if(CTimer::GetTimeInMilliseconds() > aSkidmarks[i].m_fadeEnd)
+				aSkidmarks[i].m_state = 0;
+			break;
+		}
+		aSkidmarks[i].m_wasUpdated = false;
+	}
+}
+
+void
+CSkidmarks::Render(void)
+{
+	int i, j;
+	RwTexture *lastTex = nil;
+
+	PUSH_RENDERGROUP("CSkidmarks::Render");
+
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	for(i = 0; i < NUMSKIDMARKS; i++){
+		if(aSkidmarks[i].m_state == 0 || aSkidmarks[i].m_last < 1)
+			continue;
+
+		if(aSkidmarks[i].m_isBloody){
+			if(lastTex != gpSkidBloodTex){
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpSkidBloodTex));
+				lastTex = gpSkidBloodTex;
+			}
+		}else if(aSkidmarks[i].m_isMuddy){
+			if(lastTex != gpSkidMudTex){
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpSkidMudTex));
+				lastTex = gpSkidMudTex;
+			}
+		}else{
+			if(lastTex != gpSkidTex){
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpSkidTex));
+				lastTex = gpSkidTex;
+			}
+		}
+
+		uint32 fade, alpha;
+		if(aSkidmarks[i].m_state == 1 || CTimer::GetTimeInMilliseconds() < aSkidmarks[i].m_fadeStart)
+			fade = 255;
+		else
+			fade = 255*(aSkidmarks[i].m_fadeEnd - CTimer::GetTimeInMilliseconds()) / (aSkidmarks[i].m_fadeEnd - aSkidmarks[i].m_fadeStart);
+
+		for(j = 0; j <= aSkidmarks[i].m_last; j++){
+			alpha = 128;
+			if(j == 0 || j == aSkidmarks[i].m_last && aSkidmarks[i].m_state == 2)
+				alpha = 0;
+			alpha = alpha*fade/256;
+
+			CVector p1 = aSkidmarks[i].m_pos[j] + aSkidmarks[i].m_side[j];
+			CVector p2 = aSkidmarks[i].m_pos[j] - aSkidmarks[i].m_side[j];
+			RwIm3DVertexSetRGBA(&SkidmarkVertices[j*2+0], 255, 255, 255, alpha);
+			RwIm3DVertexSetPos(&SkidmarkVertices[j*2+0], p1.x, p1.y, p1.z+0.1f);
+			RwIm3DVertexSetRGBA(&SkidmarkVertices[j*2+1], 255, 255, 255, alpha);
+			RwIm3DVertexSetPos(&SkidmarkVertices[j*2+1], p2.x, p2.y, p2.z+0.1f);
+		}
+
+		LittleTest();
+		if(RwIm3DTransform(SkidmarkVertices, 2*(aSkidmarks[i].m_last+1), nil, rwIM3D_VERTEXUV)){
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, SkidmarkIndexList, 6*aSkidmarks[i].m_last);
+			RwIm3DEnd();
+		}
+	}
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+
+	POP_RENDERGROUP();
+}
+
+void
+CSkidmarks::RegisterOne(uintptr id, CVector pos, float fwdX, float fwdY, bool *isMuddy, bool *isBloody)
+{
+	int i;
+	CVector2D fwd(fwdX, fwdY);
+
+	if(CReplay::IsPlayingBack())
+		return;
+
+	// Find a skidmark to continue
+	for(i = 0; i < NUMSKIDMARKS; i++)
+		if(aSkidmarks[i].m_state == 1 && aSkidmarks[i].m_id == id)
+			break;
+
+	if(i < NUMSKIDMARKS){
+		// Continue this one
+
+		if(aSkidmarks[i].m_isBloody != *isBloody){
+			// Blood-status changed, end this one
+			aSkidmarks[i].m_state = 2;
+			aSkidmarks[i].m_fadeStart = CTimer::GetTimeInMilliseconds() + 10000;
+			aSkidmarks[i].m_fadeEnd = CTimer::GetTimeInMilliseconds() + 20000;
+			return;
+		}
+
+		aSkidmarks[i].m_wasUpdated = true;
+
+		if(CTimer::GetTimeInMilliseconds() - aSkidmarks[i].m_lastUpdate <= 100){
+			// Last update was recently, just change last coords
+			aSkidmarks[i].m_pos[aSkidmarks[i].m_last] = pos;
+			return;
+		}
+		aSkidmarks[i].m_lastUpdate = CTimer::GetTimeInMilliseconds();
+
+		if(aSkidmarks[i].m_last >= SKIDMARK_LENGTH-1){
+			// No space to continue, end it
+			aSkidmarks[i].m_state = 2;
+			aSkidmarks[i].m_fadeStart = CTimer::GetTimeInMilliseconds() + 10000;
+			aSkidmarks[i].m_fadeEnd = CTimer::GetTimeInMilliseconds() + 20000;
+			*isBloody = false;	// stpo blood marks at end
+			return;
+		}
+		aSkidmarks[i].m_last++;
+
+		aSkidmarks[i].m_pos[aSkidmarks[i].m_last] = pos;
+
+		CVector2D right(aSkidmarks[i].m_pos[aSkidmarks[i].m_last].y - aSkidmarks[i].m_pos[aSkidmarks[i].m_last - 1].y,
+		                aSkidmarks[i].m_pos[aSkidmarks[i].m_last - 1].x - aSkidmarks[i].m_pos[aSkidmarks[i].m_last].x);
+
+		right.NormaliseSafe();
+		fwd.NormaliseSafe();
+		float turn = DotProduct2D(fwd, right);
+		turn = Abs(turn) + 1.0f;
+		aSkidmarks[i].m_side[aSkidmarks[i].m_last] = CVector(right.x, right.y, 0.0f) * turn * 0.125f;
+		if(aSkidmarks[i].m_last == 1)
+			aSkidmarks[i].m_side[0] = aSkidmarks[i].m_side[1];
+
+		if(aSkidmarks[i].m_last > 8)
+			*isBloody = false;	// stop blood marks after 8
+		return;
+	}
+
+	// Start a new one
+	for(i = 0; i < NUMSKIDMARKS; i++)
+		if(aSkidmarks[i].m_state == 0)
+			break;
+	if(i < NUMSKIDMARKS){
+		// Found a free slot
+		aSkidmarks[i].m_state = 1;
+		aSkidmarks[i].m_id = id;
+		aSkidmarks[i].m_pos[0] = pos;
+		aSkidmarks[i].m_side[0] = CVector(0.0f, 0.0f, 0.0f);
+		aSkidmarks[i].m_wasUpdated = true;
+		aSkidmarks[i].m_last = 0;
+		aSkidmarks[i].m_lastUpdate = CTimer::GetTimeInMilliseconds() - 1000;
+		aSkidmarks[i].m_isBloody = *isBloody;
+		aSkidmarks[i].m_isMuddy = *isMuddy;
+	}else
+		*isBloody = false;	// stop blood marks if no space
+}
diff --git a/src/renderer/Skidmarks.h b/src/renderer/Skidmarks.h
new file mode 100644
index 00000000..c061782d
--- /dev/null
+++ b/src/renderer/Skidmarks.h
@@ -0,0 +1,32 @@
+#pragma once
+
+enum { SKIDMARK_LENGTH = 16 };
+
+class CSkidmark
+{
+public:
+	uint8 m_state;
+	bool m_wasUpdated;
+	bool m_isBloody;
+	bool m_isMuddy;
+	uintptr m_id;
+	int16 m_last;
+	uint32 m_lastUpdate;
+	uint32 m_fadeStart;
+	uint32 m_fadeEnd;
+	CVector m_pos[SKIDMARK_LENGTH];
+	CVector m_side[SKIDMARK_LENGTH];
+};
+
+class CSkidmarks
+{
+	static CSkidmark aSkidmarks[NUMSKIDMARKS];
+public:
+
+	static void Init(void);
+	static void Shutdown(void);
+	static void Clear(void);
+	static void Update(void);
+	static void Render(void);
+	static void RegisterOne(uintptr id, CVector pos, float fwdX, float fwdY, bool *isMuddy, bool *isBloody);
+};
diff --git a/src/renderer/SpecialFX.cpp b/src/renderer/SpecialFX.cpp
new file mode 100644
index 00000000..6d96d21a
--- /dev/null
+++ b/src/renderer/SpecialFX.cpp
@@ -0,0 +1,1194 @@
+#include "common.h"
+
+#include "SpecialFX.h"
+#include "RenderBuffer.h"
+#include "Timer.h"
+#include "Sprite.h"
+#include "Font.h"
+#include "Text.h"
+#include "TxdStore.h"
+#include "FileMgr.h"
+#include "FileLoader.h"
+#include "Timecycle.h"
+#include "Lights.h"
+#include "ModelIndices.h"
+#include "VisibilityPlugins.h"
+#include "World.h"
+#include "PlayerPed.h"
+#include "Particle.h"
+#include "Shadows.h"
+#include "General.h"
+#include "Camera.h"
+#include "Shadows.h"
+#include "main.h"
+
+RwIm3DVertex StreakVertices[4];
+RwImVertexIndex StreakIndexList[12];
+
+RwIm3DVertex TraceVertices[6];
+RwImVertexIndex TraceIndexList[12];
+
+
+void
+CSpecialFX::Init(void)
+{
+	CBulletTraces::Init();
+
+	RwIm3DVertexSetU(&StreakVertices[0], 0.0f);
+	RwIm3DVertexSetV(&StreakVertices[0], 0.0f);
+	RwIm3DVertexSetU(&StreakVertices[1], 1.0f);
+	RwIm3DVertexSetV(&StreakVertices[1], 0.0f);
+	RwIm3DVertexSetU(&StreakVertices[2], 0.0f);
+	RwIm3DVertexSetV(&StreakVertices[2], 0.0f);
+	RwIm3DVertexSetU(&StreakVertices[3], 1.0f);
+	RwIm3DVertexSetV(&StreakVertices[3], 0.0f);
+
+	StreakIndexList[0] = 0;
+	StreakIndexList[1] = 1;
+	StreakIndexList[2] = 2;
+	StreakIndexList[3] = 1;
+	StreakIndexList[4] = 3;
+	StreakIndexList[5] = 2;
+	StreakIndexList[6] = 0;
+	StreakIndexList[7] = 2;
+	StreakIndexList[8] = 1;
+	StreakIndexList[9] = 1;
+	StreakIndexList[10] = 2;
+	StreakIndexList[11] = 3;
+
+	RwIm3DVertexSetRGBA(&TraceVertices[0], 20, 20, 20, 255);
+	RwIm3DVertexSetRGBA(&TraceVertices[1], 20, 20, 20, 255);
+	RwIm3DVertexSetRGBA(&TraceVertices[2], 70, 70, 70, 255);
+	RwIm3DVertexSetRGBA(&TraceVertices[3], 70, 70, 70, 255);
+	RwIm3DVertexSetRGBA(&TraceVertices[4], 10, 10, 10, 255);
+	RwIm3DVertexSetRGBA(&TraceVertices[5], 10, 10, 10, 255);
+	RwIm3DVertexSetU(&TraceVertices[0], 0.0);
+	RwIm3DVertexSetV(&TraceVertices[0], 0.0);
+	RwIm3DVertexSetU(&TraceVertices[1], 1.0);
+	RwIm3DVertexSetV(&TraceVertices[1], 0.0);
+	RwIm3DVertexSetU(&TraceVertices[2], 0.0);
+	RwIm3DVertexSetV(&TraceVertices[2], 0.5);
+	RwIm3DVertexSetU(&TraceVertices[3], 1.0);
+	RwIm3DVertexSetV(&TraceVertices[3], 0.5);
+	RwIm3DVertexSetU(&TraceVertices[4], 0.0);
+	RwIm3DVertexSetV(&TraceVertices[4], 1.0);
+	RwIm3DVertexSetU(&TraceVertices[5], 1.0);
+	RwIm3DVertexSetV(&TraceVertices[5], 1.0);
+
+	TraceIndexList[0] = 0;
+	TraceIndexList[1] = 2;
+	TraceIndexList[2] = 1;
+	TraceIndexList[3] = 1;
+	TraceIndexList[4] = 2;
+	TraceIndexList[5] = 3;
+	TraceIndexList[6] = 2;
+	TraceIndexList[7] = 4;
+	TraceIndexList[8] = 3;
+	TraceIndexList[9] = 3;
+	TraceIndexList[10] = 4;
+	TraceIndexList[11] = 5;
+
+	CMotionBlurStreaks::Init();
+	CBrightLights::Init();
+	CShinyTexts::Init();
+	CMoneyMessages::Init();
+	C3dMarkers::Init();
+}
+
+RwObject*
+LookForBatCB(RwObject *object, void *data)
+{
+	static CMatrix MatLTM;
+
+	if(CVisibilityPlugins::GetAtomicModelInfo((RpAtomic*)object) == (CSimpleModelInfo*)data){
+		MatLTM = CMatrix(RwFrameGetLTM(RpAtomicGetFrame((RpAtomic*)object)));
+		CVector p1 = MatLTM * CVector(0.02f, 0.05f, 0.07f);
+		CVector p2 = MatLTM * CVector(0.246f, 0.0325f, 0.796f);
+		CMotionBlurStreaks::RegisterStreak((uintptr)object, 100, 100, 100, p1, p2);
+	}
+	return nil;
+}
+
+void
+CSpecialFX::Update(void)
+{
+	CMotionBlurStreaks::Update();
+	CBulletTraces::Update();
+
+	if(FindPlayerPed() &&
+	   FindPlayerPed()->GetWeapon()->m_eWeaponType == WEAPONTYPE_BASEBALLBAT &&
+	   FindPlayerPed()->GetWeapon()->m_eWeaponState == WEAPONSTATE_FIRING){
+#ifdef PED_SKIN
+		if(IsClumpSkinned(FindPlayerPed()->GetClump())){
+			LookForBatCB((RwObject*)FindPlayerPed()->m_pWeaponModel, CModelInfo::GetModelInfo(MI_BASEBALL_BAT));
+		}else
+#endif
+			RwFrameForAllObjects(FindPlayerPed()->m_pFrames[PED_HANDR]->frame, LookForBatCB, CModelInfo::GetModelInfo(MI_BASEBALL_BAT));
+	}
+}
+
+void
+CSpecialFX::Shutdown(void)
+{
+	C3dMarkers::Shutdown();
+}
+
+void
+CSpecialFX::Render(void)
+{
+	PUSH_RENDERGROUP("CSpecialFX::Render");
+	CMotionBlurStreaks::Render();
+	CBulletTraces::Render();
+	CBrightLights::Render();
+	CShinyTexts::Render();
+	CMoneyMessages::Render();
+#ifdef NEW_RENDERER
+	if(!(gbNewRenderer && FredIsInFirstPersonCam()))
+#endif
+	C3dMarkers::Render();
+	POP_RENDERGROUP();
+}
+
+CRegisteredMotionBlurStreak CMotionBlurStreaks::aStreaks[NUMMBLURSTREAKS];
+
+void
+CRegisteredMotionBlurStreak::Update(void)
+{
+	int i;
+	bool wasUpdated;
+	bool lastWasUpdated = false;
+	for(i = 2; i > 0; i--){
+		m_pos1[i] = m_pos1[i-1];
+		m_pos2[i] = m_pos2[i-1];
+		m_isValid[i] = m_isValid[i-1];
+		wasUpdated = true;
+		if(!lastWasUpdated && !m_isValid[i])
+			wasUpdated = false;
+		lastWasUpdated = wasUpdated;
+	}
+	m_isValid[0] = false;
+	if(!wasUpdated)
+		m_id = 0;
+}
+
+void
+CRegisteredMotionBlurStreak::Render(void)
+{
+	int i;
+	int a1, a2;
+	for(i = 0; i < 2; i++)
+		if(m_isValid[i] && m_isValid[i+1]){
+			a1 = (255/3)*(3-i)/3;
+			RwIm3DVertexSetRGBA(&StreakVertices[0], m_red, m_green, m_blue, a1);
+			RwIm3DVertexSetRGBA(&StreakVertices[1], m_red, m_green, m_blue, a1);
+			a2 = (255/3)*(3-(i+1))/3;
+			RwIm3DVertexSetRGBA(&StreakVertices[2], m_red, m_green, m_blue, a2);
+			RwIm3DVertexSetRGBA(&StreakVertices[3], m_red, m_green, m_blue, a2);
+			RwIm3DVertexSetPos(&StreakVertices[0], m_pos1[i].x, m_pos1[i].y, m_pos1[i].z);
+			RwIm3DVertexSetPos(&StreakVertices[1], m_pos2[i].x, m_pos2[i].y, m_pos2[i].z);
+			RwIm3DVertexSetPos(&StreakVertices[2], m_pos1[i+1].x, m_pos1[i+1].y, m_pos1[i+1].z);
+			RwIm3DVertexSetPos(&StreakVertices[3], m_pos2[i+1].x, m_pos2[i+1].y, m_pos2[i+1].z);
+			LittleTest();
+			if(RwIm3DTransform(StreakVertices, 4, nil, rwIM3D_VERTEXUV)){
+				RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, StreakIndexList, 12);
+				RwIm3DEnd();
+			}
+		}
+}
+
+void
+CMotionBlurStreaks::Init(void)
+{
+	int i;
+	for(i = 0; i < NUMMBLURSTREAKS; i++)
+		aStreaks[i].m_id = 0;
+}
+
+void
+CMotionBlurStreaks::Update(void)
+{
+	int i;
+	for(i = 0; i < NUMMBLURSTREAKS; i++)
+		if(aStreaks[i].m_id != 0)
+			aStreaks[i].Update();
+}
+
+void
+CMotionBlurStreaks::RegisterStreak(uintptr id, uint8 r, uint8 g, uint8 b, CVector p1, CVector p2)
+{
+	int i;
+	for(i = 0; i < NUMMBLURSTREAKS; i++){
+		if(aStreaks[i].m_id == id){
+			// Found a streak from last frame, update
+			aStreaks[i].m_red = r;
+			aStreaks[i].m_green = g;
+			aStreaks[i].m_blue = b;
+			aStreaks[i].m_pos1[0] = p1;
+			aStreaks[i].m_pos2[0] = p2;
+			aStreaks[i].m_isValid[0] = true;
+			return;
+		}
+	}
+	// Find free slot
+	for(i = 0; aStreaks[i].m_id != 0; i++)
+		if(i == NUMMBLURSTREAKS-1)
+			return;
+	// Create a new streak
+	aStreaks[i].m_id = id;
+	aStreaks[i].m_red = r;
+	aStreaks[i].m_green = g;
+	aStreaks[i].m_blue = b;
+	aStreaks[i].m_pos1[0] = p1;
+	aStreaks[i].m_pos2[0] = p2;
+	aStreaks[i].m_isValid[0] = true;
+	aStreaks[i].m_isValid[1] = false;
+	aStreaks[i].m_isValid[2] = false;
+}
+
+void
+CMotionBlurStreaks::Render(void)
+{
+	bool setRenderStates = false;
+	int i;
+	for(i = 0; i < NUMMBLURSTREAKS; i++)
+		if(aStreaks[i].m_id != 0){
+			if(!setRenderStates){
+				RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+				RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+				RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void *)TRUE);
+				RwRenderStateSet(rwRENDERSTATEFOGCOLOR,
+					(void*)RWRGBALONG(CTimeCycle::GetFogRed(), CTimeCycle::GetFogGreen(), CTimeCycle::GetFogBlue(), 255));
+				RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+				RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)FALSE);
+ 				setRenderStates = true;
+			}
+			aStreaks[i].Render();
+		}
+	if(setRenderStates){
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void *)FALSE);
+	}
+}
+
+
+CBulletTrace CBulletTraces::aTraces[NUMBULLETTRACES];
+
+void CBulletTraces::Init(void)
+{
+	for (int i = 0; i < NUMBULLETTRACES; i++)
+		aTraces[i].m_bInUse = false;
+}
+
+void CBulletTraces::AddTrace(CVector* vecStart, CVector* vecTarget)
+{
+	int index;
+	for (index = 0; index < NUMBULLETTRACES; index++) {
+		if (!aTraces[index].m_bInUse)
+			break;
+	}
+	if (index == NUMBULLETTRACES)
+		return;
+	aTraces[index].m_vecCurrentPos = *vecStart;
+	aTraces[index].m_vecTargetPos = *vecTarget;
+	aTraces[index].m_bInUse = true;
+	aTraces[index].m_framesInUse = 0;
+	aTraces[index].m_lifeTime = 25 + CGeneral::GetRandomNumber() % 32;
+}
+
+void CBulletTraces::Render(void)
+{
+	for (int i = 0; i < NUMBULLETTRACES; i++) {
+		if (!aTraces[i].m_bInUse)
+			continue;
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+#ifdef FIX_BUGS
+		// Raster has no transparent pixels so it relies on the raster format having alpha
+		// to turn on blending. librw image conversion might get rid of it right now so let's
+		// just force it on.
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+#endif
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpShadowExplosionTex));
+		CVector inf = aTraces[i].m_vecCurrentPos;
+		CVector sup = aTraces[i].m_vecTargetPos;
+		CVector center = (inf + sup) / 2;
+		CVector width = CrossProduct(TheCamera.GetForward(), (sup - inf));
+		width.Normalise();
+		width /= 20;
+		uint8 intensity = aTraces[i].m_lifeTime;
+		for (int i = 0; i < ARRAY_SIZE(TraceVertices); i++)
+			RwIm3DVertexSetRGBA(&TraceVertices[i], intensity, intensity, intensity, 0xFF);
+		RwIm3DVertexSetPos(&TraceVertices[0], inf.x + width.x, inf.y + width.y, inf.z + width.z);
+		RwIm3DVertexSetPos(&TraceVertices[1], inf.x - width.x, inf.y - width.y, inf.z - width.z);
+		RwIm3DVertexSetPos(&TraceVertices[2], center.x + width.x, center.y + width.y, center.z + width.z);
+		RwIm3DVertexSetPos(&TraceVertices[3], center.x - width.x, center.y - width.y, center.z - width.z);
+		RwIm3DVertexSetPos(&TraceVertices[4], sup.x + width.x, sup.y + width.y, sup.z + width.z);
+		RwIm3DVertexSetPos(&TraceVertices[5], sup.x - width.x, sup.y - width.y, sup.z - width.z);
+		LittleTest();
+		if (RwIm3DTransform(TraceVertices, ARRAY_SIZE(TraceVertices), nil, rwIM3D_VERTEXUV)) {
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TraceIndexList, ARRAY_SIZE(TraceIndexList));
+			RwIm3DEnd();
+		}
+	}
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+}
+
+void CBulletTraces::Update(void)
+{
+	for (int i = 0; i < NUMBULLETTRACES; i++) {
+		if (aTraces[i].m_bInUse)
+			aTraces[i].Update();
+	}
+}
+
+void CBulletTrace::Update(void)
+{
+	if (m_framesInUse == 0) {
+		m_framesInUse++;
+		return;
+	}
+	if (m_framesInUse > 60) {
+		m_bInUse = false;
+		return;
+	}
+	CVector diff = m_vecCurrentPos - m_vecTargetPos;
+	float remaining = diff.Magnitude();
+	if (remaining > 0.8f)
+		m_vecCurrentPos = m_vecTargetPos + (remaining - 0.8f) / remaining * diff;
+	else
+		m_bInUse = false;
+	if (--m_lifeTime == 0)
+		m_bInUse = false;
+	m_framesInUse++;
+}
+
+RpAtomic *
+MarkerAtomicCB(RpAtomic *atomic, void *data)
+{
+	*(RpAtomic**)data = atomic;
+	return atomic;
+}
+
+bool
+C3dMarker::AddMarker(uint32 identifier, uint16 type, float fSize, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate)
+{
+	m_nIdentifier = identifier;
+
+	m_Matrix.SetUnity();
+
+	RpAtomic *origAtomic;
+	origAtomic = nil;
+	RpClumpForAllAtomics(C3dMarkers::m_pRpClumpArray[type], MarkerAtomicCB, &origAtomic);
+
+	RpAtomic *atomic = RpAtomicClone(origAtomic);
+	RwFrame *frame = RwFrameCreate();
+	RpAtomicSetFrame(atomic, frame);
+	CVisibilityPlugins::SetAtomicRenderCallback(atomic, nil);
+	
+	RpGeometry *geometry = RpAtomicGetGeometry(atomic);
+	RpGeometrySetFlags(geometry, RpGeometryGetFlags(geometry) | rpGEOMETRYMODULATEMATERIALCOLOR);
+
+	m_pAtomic = atomic;
+	m_Matrix.Attach(RwFrameGetMatrix(RpAtomicGetFrame(m_pAtomic)));
+	m_pMaterial = RpGeometryGetMaterial(geometry, 0);
+	m_fSize = fSize;
+	m_fStdSize = m_fSize;
+	m_Color.red = r;
+	m_Color.green = g;
+	m_Color.blue = b;
+	m_Color.alpha = a;
+	m_nPulsePeriod = pulsePeriod;
+	m_fPulseFraction = pulseFraction;
+	m_nRotateRate = rotateRate;
+	m_nStartTime = CTimer::GetTimeInMilliseconds();
+	m_nType = type;
+	return m_pAtomic != nil;
+}
+
+void
+C3dMarker::DeleteMarkerObject()
+{
+	RwFrame *frame;
+
+	m_nIdentifier = 0;
+	m_nStartTime = 0;
+	m_bIsUsed = false;
+	m_nType = MARKERTYPE_INVALID;
+
+	frame = RpAtomicGetFrame(m_pAtomic);
+	RpAtomicDestroy(m_pAtomic);
+	RwFrameDestroy(frame);
+	m_pAtomic = nil;
+}
+
+void
+C3dMarker::Render()
+{
+	if (m_pAtomic == nil) return;
+
+	RpMaterialSetColor(m_pMaterial, &m_Color);
+
+	m_Matrix.UpdateRW();
+
+	CMatrix matrix;
+	matrix.Attach(m_Matrix.m_attachment);
+	matrix.Scale(m_fSize);
+	matrix.UpdateRW();
+
+	RwFrameUpdateObjects(RpAtomicGetFrame(m_pAtomic));
+	SetBrightMarkerColours(m_fBrightness);
+	if (m_nType != MARKERTYPE_ARROW)
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RpAtomicRender(m_pAtomic);
+	if (m_nType != MARKERTYPE_ARROW)
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	ReSetAmbientAndDirectionalColours();
+}
+
+C3dMarker C3dMarkers::m_aMarkerArray[NUM3DMARKERS];
+int32 C3dMarkers::NumActiveMarkers;
+RpClump* C3dMarkers::m_pRpClumpArray[NUMMARKERTYPES];
+
+void
+C3dMarkers::Init()
+{
+	for (int i = 0; i < NUM3DMARKERS; i++) {
+		m_aMarkerArray[i].m_pAtomic = nil;
+		m_aMarkerArray[i].m_nType = MARKERTYPE_INVALID;
+		m_aMarkerArray[i].m_bIsUsed = false;
+		m_aMarkerArray[i].m_nIdentifier = 0;
+		m_aMarkerArray[i].m_Color.red = 255;
+		m_aMarkerArray[i].m_Color.green = 255;
+		m_aMarkerArray[i].m_Color.blue = 255;
+		m_aMarkerArray[i].m_Color.alpha = 255;
+		m_aMarkerArray[i].m_nPulsePeriod = 1024;
+		m_aMarkerArray[i].m_nRotateRate = 5;
+		m_aMarkerArray[i].m_nStartTime = 0;
+		m_aMarkerArray[i].m_fPulseFraction = 0.25f;
+		m_aMarkerArray[i].m_fStdSize = 1.0f;
+		m_aMarkerArray[i].m_fSize = 1.0f;
+		m_aMarkerArray[i].m_fBrightness = 1.0f;
+		m_aMarkerArray[i].m_fCameraRange = 0.0f;
+	}
+	NumActiveMarkers = 0;
+	int txdSlot = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::PushCurrentTxd();
+	CTxdStore::SetCurrentTxd(txdSlot);
+	CFileMgr::ChangeDir("\\");
+	m_pRpClumpArray[MARKERTYPE_ARROW] = CFileLoader::LoadAtomicFile2Return("models/generic/arrow.dff");
+	m_pRpClumpArray[MARKERTYPE_CYLINDER] = CFileLoader::LoadAtomicFile2Return("models/generic/zonecylb.dff");
+	CTxdStore::PopCurrentTxd();
+}
+
+void
+C3dMarkers::Shutdown()
+{
+	for (int i = 0; i < NUM3DMARKERS; i++) {
+		if (m_aMarkerArray[i].m_pAtomic != nil)
+			m_aMarkerArray[i].DeleteMarkerObject();
+	}
+
+	for (int i = 0; i < NUMMARKERTYPES; i++) {
+		if (m_pRpClumpArray[i] != nil)
+			RpClumpDestroy(m_pRpClumpArray[i]);
+	}
+}
+
+void
+C3dMarkers::Render()
+{
+	NumActiveMarkers = 0;
+	ActivateDirectional();
+	for (int i = 0; i < NUM3DMARKERS; i++) {
+		if (m_aMarkerArray[i].m_bIsUsed) {
+			if (m_aMarkerArray[i].m_fCameraRange < 120.0f)
+				m_aMarkerArray[i].Render();
+			NumActiveMarkers++;
+			m_aMarkerArray[i].m_bIsUsed = false;
+		} else if (m_aMarkerArray[i].m_pAtomic != nil) {
+			m_aMarkerArray[i].DeleteMarkerObject();
+		}
+	}
+}
+
+C3dMarker *
+C3dMarkers::PlaceMarker(uint32 identifier, uint16 type, CVector &pos, float size, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate)
+{
+	C3dMarker *pMarker;
+
+	pMarker = nil;
+	float dist = Sqrt((pos.x - FindPlayerCentreOfWorld(0).x) * (pos.x - FindPlayerCentreOfWorld(0).x) + (pos.y - FindPlayerCentreOfWorld(0).y) * (pos.y - FindPlayerCentreOfWorld(0).y));
+
+	if (type != MARKERTYPE_ARROW && type != MARKERTYPE_CYLINDER) return nil;
+
+	for (int i = 0; i < NUM3DMARKERS; i++) {
+		if (!m_aMarkerArray[i].m_bIsUsed && m_aMarkerArray[i].m_nIdentifier == identifier) {
+			pMarker = &m_aMarkerArray[i];
+			break;
+		}
+	}
+
+	if (pMarker == nil) {
+		for (int i = 0; i < NUM3DMARKERS; i++) {
+			if (m_aMarkerArray[i].m_nType == MARKERTYPE_INVALID) {
+				pMarker = &m_aMarkerArray[i];
+				break;
+			}
+		}
+	}
+
+	if (pMarker == nil && type == MARKERTYPE_ARROW) {
+		for (int i = 0; i < NUM3DMARKERS; i++) {
+			if (dist < m_aMarkerArray[i].m_fCameraRange && m_aMarkerArray[i].m_nType == MARKERTYPE_ARROW && (pMarker == nil || m_aMarkerArray[i].m_fCameraRange > pMarker->m_fCameraRange)) {
+				pMarker = &m_aMarkerArray[i];
+				break;
+			}
+		}
+
+		if (pMarker != nil)
+			pMarker->m_nType = MARKERTYPE_INVALID;
+	}
+
+	if (pMarker == nil) return pMarker;
+
+	pMarker->m_fCameraRange = dist;
+	if (pMarker->m_nIdentifier == identifier && pMarker->m_nType == type) {
+		if (type == MARKERTYPE_ARROW) {
+			if (dist < 25.0f) {
+				if (dist > 5.0f)
+					pMarker->m_fStdSize = size - (25.0f - dist) * (0.3f * size) / 20.0f;
+				else
+					pMarker->m_fStdSize = size - 0.3f * size;
+			} else {
+				pMarker->m_fStdSize = size;
+			}
+		} else if (type == MARKERTYPE_CYLINDER) {
+			if (dist < size + 12.0f) {
+				if (dist > size + 1.0f)
+					pMarker->m_Color.alpha = (1.0f - (size + 12.0f - dist) * 0.7f / 11.0f) * (float)a;
+				else
+					pMarker->m_Color.alpha = (float)a * 0.3f;
+			} else {
+				pMarker->m_Color.alpha = a;
+			}
+		}
+		float someSin = Sin(TWOPI * (float)((pMarker->m_nPulsePeriod - 1) & (CTimer::GetTimeInMilliseconds() - pMarker->m_nStartTime)) / (float)pMarker->m_nPulsePeriod);
+		pMarker->m_fSize = pMarker->m_fStdSize - pulseFraction * pMarker->m_fStdSize * someSin;
+
+		if (type == MARKERTYPE_ARROW) {
+			pos.z += 0.25f * pMarker->m_fStdSize * someSin;
+		} else if (type == MARKERTYPE_0) {
+			if (someSin > 0.0f)
+				pMarker->m_Color.alpha = (float)a * 0.7f * someSin + a;
+			else
+				pMarker->m_Color.alpha = (float)a * 0.4f * someSin + a;
+		}
+		if (pMarker->m_nRotateRate) {
+			CVector pos = pMarker->m_Matrix.GetPosition();
+			pMarker->m_Matrix.RotateZ(DEGTORAD(pMarker->m_nRotateRate * CTimer::GetTimeStep()));
+			pMarker->m_Matrix.GetPosition() = pos;
+		}
+		if (type == MARKERTYPE_ARROW)
+			pMarker->m_Matrix.GetPosition() = pos;
+		pMarker->m_bIsUsed = true;
+		return pMarker;
+	}
+
+	if (pMarker->m_nIdentifier != 0)
+		pMarker->DeleteMarkerObject();
+
+	pMarker->AddMarker(identifier, type, size, r, g, b, a, pulsePeriod, pulseFraction, rotateRate);
+	if (type == MARKERTYPE_CYLINDER || type == MARKERTYPE_0 || type == MARKERTYPE_2) {
+		float z = CWorld::FindGroundZFor3DCoord(pos.x, pos.y, pos.z + 1.0f, nil);
+		if (z != 0.0f)
+			pos.z = z - 0.05f * size;
+	}
+	pMarker->m_Matrix.SetTranslate(pos.x, pos.y, pos.z);
+	if (type == MARKERTYPE_2) {
+		pMarker->m_Matrix.RotateX(PI);
+		pMarker->m_Matrix.GetPosition() = pos;
+	}
+	pMarker->m_Matrix.UpdateRW();
+	if (type == MARKERTYPE_ARROW) {
+		if (dist < 25.0f) {
+			if (dist > 5.0f)
+				pMarker->m_fStdSize = size - (25.0f - dist) * (0.3f * size) / 20.0f;
+			else
+				pMarker->m_fStdSize = size - 0.3f * size;
+		} else {
+			pMarker->m_fStdSize = size;
+		}
+	} else if (type == MARKERTYPE_CYLINDER) {
+		if (dist < size + 12.0f) {
+			if (dist > size + 1.0f)
+				pMarker->m_Color.alpha = (1.0f - (size + 12.0f - dist) * 0.7f / 11.0f) * (float)a;
+			else
+				pMarker->m_Color.alpha = (float)a * 0.3f;
+		} else {
+			pMarker->m_Color.alpha = a;
+		}
+	}
+	pMarker->m_bIsUsed = true;
+	return pMarker;
+}
+
+void
+C3dMarkers::PlaceMarkerSet(uint32 id, uint16 type, CVector &pos, float size, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate)
+{
+	PlaceMarker(id, type, pos, size, r, g, b, a, pulsePeriod, pulseFraction, 1);
+	PlaceMarker(id, type, pos, size * 0.93f, r, g, b, a, pulsePeriod, pulseFraction, 2);
+	PlaceMarker(id, type, pos, size * 0.86f, r, g, b, a, pulsePeriod, pulseFraction, -1);
+}
+
+
+void
+C3dMarkers::Update()
+{
+}
+
+
+#define BRIGHTLIGHTS_MAX_DIST (60.0f)	// invisible beyond this
+#define BRIGHTLIGHTS_FADE_DIST (45.0f)	// strongest between these two
+#define CARLIGHTS_MAX_DIST (30.0f)
+#define CARLIGHTS_FADE_DIST (15.0f)	// 31 for close lights
+
+int CBrightLights::NumBrightLights;
+CBrightLight CBrightLights::aBrightLights[NUMBRIGHTLIGHTS];
+
+void
+CBrightLights::Init(void)
+{
+	NumBrightLights = 0;
+}
+
+void
+CBrightLights::RegisterOne(CVector pos, CVector up, CVector side, CVector front,
+	uint8 type, uint8 red, uint8 green, uint8 blue)
+{
+	if(NumBrightLights >= NUMBRIGHTLIGHTS)
+		return;
+
+	aBrightLights[NumBrightLights].m_camDist = (pos - TheCamera.GetPosition()).Magnitude();
+	if(aBrightLights[NumBrightLights].m_camDist > BRIGHTLIGHTS_MAX_DIST)
+		return;
+
+	aBrightLights[NumBrightLights].m_pos = pos;
+	aBrightLights[NumBrightLights].m_up = up;
+	aBrightLights[NumBrightLights].m_side = side;
+	aBrightLights[NumBrightLights].m_front = front;
+	aBrightLights[NumBrightLights].m_type = type;
+	aBrightLights[NumBrightLights].m_red = red;
+	aBrightLights[NumBrightLights].m_green = green;
+	aBrightLights[NumBrightLights].m_blue = blue;
+
+	NumBrightLights++;
+}
+
+static float TrafficLightsSide[6] = { -0.09f, 0.09f, 0.162f, 0.09f, -0.09f, -0.162f };
+static float TrafficLightsUp[6] = { 0.162f, 0.162f, 0.0f, -0.162f, -0.162f, 0.0f };
+static float LongCarHeadLightsSide[8] = { -0.2f, 0.2f, -0.2f, 0.2f, -0.2f, 0.2f, -0.2f, 0.2f };
+static float LongCarHeadLightsFront[8] = { 0.1f, 0.1f, -0.1f, -0.1f, 0.1f, 0.1f, -0.1f, -0.1f };
+static float LongCarHeadLightsUp[8] = { 0.1f, 0.1f, 0.1f, 0.1f, -0.1f, -0.1f, -0.1f, -0.1f };
+static float SmallCarHeadLightsSide[8] = { -0.08f, 0.08f, -0.08f, 0.08f, -0.08f, 0.08f, -0.08f, 0.08f };
+static float SmallCarHeadLightsFront[8] = { 0.08f, 0.08f, -0.08f, -0.08f, 0.08f, 0.08f, -0.08f, -0.08f };
+static float SmallCarHeadLightsUp[8] = { 0.08f, 0.08f, 0.08f, 0.08f, -0.08f, -0.08f, -0.08f, -0.08f };
+static float BigCarHeadLightsSide[8] = { -0.15f, 0.15f, -0.15f, 0.15f, -0.15f, 0.15f, -0.15f, 0.15f };
+static float BigCarHeadLightsFront[8] = { 0.15f, 0.15f, -0.15f, -0.15f, 0.15f, 0.15f, -0.15f, -0.15f };
+static float BigCarHeadLightsUp[8] = { 0.15f, 0.15f, 0.15f, 0.15f, -0.15f, -0.15f, -0.15f, -0.15f };
+static float TallCarHeadLightsSide[8] = { -0.08f, 0.08f, -0.08f, 0.08f, -0.08f, 0.08f, -0.08f, 0.08f };
+static float TallCarHeadLightsFront[8] = { 0.08f, 0.08f, -0.08f, -0.08f, 0.08f, 0.08f, -0.08f, -0.08f };
+static float TallCarHeadLightsUp[8] = { 0.2f, 0.2f, 0.2f, 0.2f, -0.2f, -0.2f, -0.2f, -0.2f };
+static float SirenLightsSide[6] = { -0.04f, 0.04f, 0.06f, 0.04f, -0.04f, -0.06f };
+static float SirenLightsUp[6] = { 0.06f, 0.06f, 0.0f, -0.06f, -0.06f, 0.0f };
+static RwImVertexIndex TrafficLightIndices[4*3] = { 0, 1, 5,  1, 2, 3,  1, 3, 4,  1, 4, 5 };
+static RwImVertexIndex CubeIndices[12*3] = {
+	0, 2, 1,  1, 2, 3,  3, 5, 1,  3, 7, 5,
+	2, 7, 3,  2, 6, 7,  4, 0, 1,  4, 1, 5,
+	6, 0, 4,  6, 2, 0,  6, 5, 7,  6, 4, 5
+};
+
+void
+CBrightLights::Render(void)
+{
+	int i, j;
+	CVector pos;
+
+	if(NumBrightLights == 0)
+		return;
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+
+	for(i = 0; i < NumBrightLights; i++){
+		if(TempBufferIndicesStored > TEMPBUFFERINDEXSIZE-40 || TempBufferVerticesStored > TEMPBUFFERVERTSIZE-40)
+			RenderOutGeometryBuffer();
+
+		int r, g, b, a;
+		float flicker = (CGeneral::GetRandomNumber()&0xFF) * 0.2f;
+		switch(aBrightLights[i].m_type){
+		case BRIGHTLIGHT_TRAFFIC_GREEN:
+			r = flicker; g = 255; b = flicker;
+			break;
+		case BRIGHTLIGHT_TRAFFIC_YELLOW:
+			r = 255; g = 128; b = flicker;
+			break;
+		case BRIGHTLIGHT_TRAFFIC_RED:
+			r = 255; g = flicker; b = flicker;
+			break;
+
+		case BRIGHTLIGHT_FRONT_LONG:
+		case BRIGHTLIGHT_FRONT_SMALL:
+		case BRIGHTLIGHT_FRONT_BIG:
+		case BRIGHTLIGHT_FRONT_TALL:
+			r = 255; g = 255; b = 255;
+			break;
+
+		case BRIGHTLIGHT_REAR_LONG:
+		case BRIGHTLIGHT_REAR_SMALL:
+		case BRIGHTLIGHT_REAR_BIG:
+		case BRIGHTLIGHT_REAR_TALL:
+			r = 255; g = flicker; b = flicker;
+			break;
+
+		case BRIGHTLIGHT_SIREN:
+			r = aBrightLights[i].m_red;
+			g = aBrightLights[i].m_green;
+			b = aBrightLights[i].m_blue;
+			break;
+		}
+
+		if(aBrightLights[i].m_camDist < BRIGHTLIGHTS_FADE_DIST)
+			a = 255;
+		else
+			a = 255*(1.0f - (aBrightLights[i].m_camDist-BRIGHTLIGHTS_FADE_DIST)/(BRIGHTLIGHTS_MAX_DIST-BRIGHTLIGHTS_FADE_DIST));
+		// fade car lights down to 31 as they come near
+		if(aBrightLights[i].m_type >= BRIGHTLIGHT_FRONT_LONG && aBrightLights[i].m_type <= BRIGHTLIGHT_REAR_TALL){
+			if(aBrightLights[i].m_camDist < CARLIGHTS_FADE_DIST)
+				a = 31;
+			else if(aBrightLights[i].m_camDist < CARLIGHTS_MAX_DIST)
+				a = 31 + (255-31)*((aBrightLights[i].m_camDist-CARLIGHTS_FADE_DIST)/(CARLIGHTS_MAX_DIST-CARLIGHTS_FADE_DIST));
+		}
+
+		switch(aBrightLights[i].m_type){
+		case BRIGHTLIGHT_TRAFFIC_GREEN:
+		case BRIGHTLIGHT_TRAFFIC_YELLOW:
+		case BRIGHTLIGHT_TRAFFIC_RED:
+			for(j = 0; j < 6; j++){
+				pos = TrafficLightsSide[j]*aBrightLights[i].m_side +
+					TrafficLightsUp[j]*aBrightLights[i].m_up +
+					aBrightLights[i].m_pos;
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored+j], r, g, b, a);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored+j], pos.x, pos.y, pos.z);
+			}
+			for(j = 0; j < 4*3; j++)
+				TempBufferRenderIndexList[TempBufferIndicesStored+j] = TrafficLightIndices[j] + TempBufferVerticesStored;
+			TempBufferVerticesStored += 6;
+			TempBufferIndicesStored += 4*3;
+			break;
+
+		case BRIGHTLIGHT_FRONT_LONG:
+		case BRIGHTLIGHT_REAR_LONG:
+			for(j = 0; j < 8; j++){
+				pos = LongCarHeadLightsSide[j]*aBrightLights[i].m_side +
+					LongCarHeadLightsUp[j]*aBrightLights[i].m_up +
+					LongCarHeadLightsFront[j]*aBrightLights[i].m_front +
+					aBrightLights[i].m_pos;
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored+j], r, g, b, a);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored+j], pos.x, pos.y, pos.z);
+			}
+			for(j = 0; j < 12*3; j++)
+				TempBufferRenderIndexList[TempBufferIndicesStored+j] = CubeIndices[j] + TempBufferVerticesStored;
+			TempBufferVerticesStored += 8;
+			TempBufferIndicesStored += 12*3;
+			break;
+
+		case BRIGHTLIGHT_FRONT_SMALL:
+		case BRIGHTLIGHT_REAR_SMALL:
+			for(j = 0; j < 8; j++){
+				pos = SmallCarHeadLightsSide[j]*aBrightLights[i].m_side +
+					SmallCarHeadLightsUp[j]*aBrightLights[i].m_up +
+					SmallCarHeadLightsFront[j]*aBrightLights[i].m_front +
+					aBrightLights[i].m_pos;
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored+j], r, g, b, a);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored+j], pos.x, pos.y, pos.z);
+			}
+			for(j = 0; j < 12*3; j++)
+				TempBufferRenderIndexList[TempBufferIndicesStored+j] = CubeIndices[j] + TempBufferVerticesStored;
+			TempBufferVerticesStored += 8;
+			TempBufferIndicesStored += 12*3;
+			break;
+
+		case BRIGHTLIGHT_FRONT_BIG:
+		case BRIGHTLIGHT_REAR_BIG:
+			for (j = 0; j < 8; j++) {
+			pos = BigCarHeadLightsSide[j] * aBrightLights[i].m_side +
+				BigCarHeadLightsUp[j] * aBrightLights[i].m_up +
+				BigCarHeadLightsFront[j] * aBrightLights[i].m_front +
+				aBrightLights[i].m_pos;
+			RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + j], r, g, b, a);
+			RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + j], pos.x, pos.y, pos.z);
+		}
+		for (j = 0; j < 12 * 3; j++)
+			TempBufferRenderIndexList[TempBufferIndicesStored + j] = CubeIndices[j] + TempBufferVerticesStored;
+		TempBufferVerticesStored += 8;
+		TempBufferIndicesStored += 12 * 3;
+		break;
+
+		case BRIGHTLIGHT_FRONT_TALL:
+		case BRIGHTLIGHT_REAR_TALL:
+			for(j = 0; j < 8; j++){
+				pos = TallCarHeadLightsSide[j]*aBrightLights[i].m_side +
+					TallCarHeadLightsUp[j]*aBrightLights[i].m_up +
+					TallCarHeadLightsFront[j]*aBrightLights[i].m_front +
+					aBrightLights[i].m_pos;
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored+j], r, g, b, a);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored+j], pos.x, pos.y, pos.z);
+			}
+			for(j = 0; j < 12*3; j++)
+				TempBufferRenderIndexList[TempBufferIndicesStored+j] = CubeIndices[j] + TempBufferVerticesStored;
+			TempBufferVerticesStored += 8;
+			TempBufferIndicesStored += 12*3;
+			break;
+
+		case BRIGHTLIGHT_SIREN:
+			for(j = 0; j < 6; j++){
+				pos = SirenLightsSide[j] * TheCamera.GetRight() +
+					SirenLightsUp[j] * TheCamera.GetUp() +
+					aBrightLights[i].m_pos;
+				RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored+j], r, g, b, a);
+				RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored+j], pos.x, pos.y, pos.z);
+			}
+			for(j = 0; j < 4*3; j++)
+				TempBufferRenderIndexList[TempBufferIndicesStored+j] = TrafficLightIndices[j] + TempBufferVerticesStored;
+			TempBufferVerticesStored += 6;
+			TempBufferIndicesStored += 4*3;
+			break;
+
+		}
+	}
+
+	RenderOutGeometryBuffer();
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	NumBrightLights = 0;
+}
+
+void
+CBrightLights::RenderOutGeometryBuffer(void)
+{
+	if(TempBufferIndicesStored != 0){
+		LittleTest();
+		if(RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV)){
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+			RwIm3DEnd();
+		}
+		TempBufferVerticesStored = 0;
+		TempBufferIndicesStored = 0;
+	}
+}
+
+int CShinyTexts::NumShinyTexts;
+CShinyText CShinyTexts::aShinyTexts[NUMSHINYTEXTS];
+
+void
+CShinyTexts::Init(void)
+{
+	NumShinyTexts = 0;
+}
+
+void
+CShinyTexts::RegisterOne(CVector p0, CVector p1, CVector p2, CVector p3,
+	float u0, float v0, float u1, float v1, float u2, float v2, float u3, float v3,
+	uint8 type, uint8 red, uint8 green, uint8 blue, float maxDist)
+{
+	if(NumShinyTexts >= NUMSHINYTEXTS)
+		return;
+
+	aShinyTexts[NumShinyTexts].m_camDist = (p0 - TheCamera.GetPosition()).Magnitude();
+	if(aShinyTexts[NumShinyTexts].m_camDist > maxDist)
+		return;
+	aShinyTexts[NumShinyTexts].m_verts[0] = p0;
+	aShinyTexts[NumShinyTexts].m_verts[1] = p1;
+	aShinyTexts[NumShinyTexts].m_verts[2] = p2;
+	aShinyTexts[NumShinyTexts].m_verts[3] = p3;
+	aShinyTexts[NumShinyTexts].m_texCoords[0].x = u0;
+	aShinyTexts[NumShinyTexts].m_texCoords[0].y = v0;
+	aShinyTexts[NumShinyTexts].m_texCoords[1].x = u1;
+	aShinyTexts[NumShinyTexts].m_texCoords[1].y = v1;
+	aShinyTexts[NumShinyTexts].m_texCoords[2].x = u2;
+	aShinyTexts[NumShinyTexts].m_texCoords[2].y = v2;
+	aShinyTexts[NumShinyTexts].m_texCoords[3].x = u3;
+	aShinyTexts[NumShinyTexts].m_texCoords[3].y = v3;
+	aShinyTexts[NumShinyTexts].m_type = type;
+	aShinyTexts[NumShinyTexts].m_red = red;
+	aShinyTexts[NumShinyTexts].m_green = green;
+	aShinyTexts[NumShinyTexts].m_blue = blue;
+	// Fade out at half the max dist
+	float halfDist = maxDist*0.5f;
+	if(aShinyTexts[NumShinyTexts].m_camDist > halfDist){
+		float f = 1.0f - (aShinyTexts[NumShinyTexts].m_camDist - halfDist)/halfDist;
+		aShinyTexts[NumShinyTexts].m_red *= f;
+		aShinyTexts[NumShinyTexts].m_green *= f;
+		aShinyTexts[NumShinyTexts].m_blue *= f;
+	}
+
+	NumShinyTexts++;
+}
+
+void
+CShinyTexts::Render(void)
+{
+	int i, ix, v;
+	RwTexture *lastTex = nil;
+
+	if(NumShinyTexts == 0)
+		return;
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+
+	for(i = 0; i < NumShinyTexts; i++){
+		if(TempBufferIndicesStored > TEMPBUFFERINDEXSIZE-64 || TempBufferVerticesStored > TEMPBUFFERVERTSIZE-62)
+			RenderOutGeometryBuffer();
+
+		uint8 r = aShinyTexts[i].m_red;
+		uint8 g = aShinyTexts[i].m_green;
+		uint8 b = aShinyTexts[i].m_blue;
+
+		switch(aShinyTexts[i].m_type){
+		case SHINYTEXT_WALK:
+			if(lastTex != gpWalkDontTex){
+				RenderOutGeometryBuffer();
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpWalkDontTex));
+				lastTex = gpWalkDontTex;
+			}
+	quad:
+			v = TempBufferVerticesStored;
+			RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+0], r, g, b, 255);
+			RwIm3DVertexSetPos(&TempBufferRenderVertices[v+0], aShinyTexts[i].m_verts[0].x, aShinyTexts[i].m_verts[0].y, aShinyTexts[i].m_verts[0].z);
+			RwIm3DVertexSetU(&TempBufferRenderVertices[v+0], aShinyTexts[i].m_texCoords[0].x);
+			RwIm3DVertexSetV(&TempBufferRenderVertices[v+0], aShinyTexts[i].m_texCoords[0].y);
+			RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+1], r, g, b, 255);
+			RwIm3DVertexSetPos(&TempBufferRenderVertices[v+1], aShinyTexts[i].m_verts[1].x, aShinyTexts[i].m_verts[1].y, aShinyTexts[i].m_verts[1].z);
+			RwIm3DVertexSetU(&TempBufferRenderVertices[v+1], aShinyTexts[i].m_texCoords[1].x);
+			RwIm3DVertexSetV(&TempBufferRenderVertices[v+1], aShinyTexts[i].m_texCoords[1].y);
+			RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+2], r, g, b, 255);
+			RwIm3DVertexSetPos(&TempBufferRenderVertices[v+2], aShinyTexts[i].m_verts[2].x, aShinyTexts[i].m_verts[2].y, aShinyTexts[i].m_verts[2].z);
+			RwIm3DVertexSetU(&TempBufferRenderVertices[v+2], aShinyTexts[i].m_texCoords[2].x);
+			RwIm3DVertexSetV(&TempBufferRenderVertices[v+2], aShinyTexts[i].m_texCoords[2].y);
+			RwIm3DVertexSetRGBA(&TempBufferRenderVertices[v+3], r, g, b, 255);
+			RwIm3DVertexSetPos(&TempBufferRenderVertices[v+3], aShinyTexts[i].m_verts[3].x, aShinyTexts[i].m_verts[3].y, aShinyTexts[i].m_verts[3].z);
+			RwIm3DVertexSetU(&TempBufferRenderVertices[v+3], aShinyTexts[i].m_texCoords[3].x);
+			RwIm3DVertexSetV(&TempBufferRenderVertices[v+3], aShinyTexts[i].m_texCoords[3].y);
+			ix = TempBufferIndicesStored;
+			TempBufferRenderIndexList[ix+0] = 0 + TempBufferVerticesStored;
+			TempBufferRenderIndexList[ix+1] = 1 + TempBufferVerticesStored;
+			TempBufferRenderIndexList[ix+2] = 2 + TempBufferVerticesStored;
+			TempBufferRenderIndexList[ix+3] = 2 + TempBufferVerticesStored;
+			TempBufferRenderIndexList[ix+4] = 1 + TempBufferVerticesStored;
+			TempBufferRenderIndexList[ix+5] = 3 + TempBufferVerticesStored;
+			TempBufferVerticesStored += 4;
+			TempBufferIndicesStored += 6;
+			break;
+
+		case SHINYTEXT_FLAT:
+			if(lastTex != nil){
+				RenderOutGeometryBuffer();
+				RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+				lastTex = nil;
+			}
+			goto quad;
+		}
+	}
+
+	RenderOutGeometryBuffer();
+	NumShinyTexts = 0;
+
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+}
+
+void
+CShinyTexts::RenderOutGeometryBuffer(void)
+{
+	if(TempBufferIndicesStored != 0){
+		LittleTest();
+		if(RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV)){
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+			RwIm3DEnd();
+		}
+		TempBufferVerticesStored = 0;
+		TempBufferIndicesStored = 0;
+	}
+}
+
+
+
+#define MONEY_MESSAGE_LIFETIME_MS 2000
+
+CMoneyMessage CMoneyMessages::aMoneyMessages[NUMMONEYMESSAGES];
+
+void
+CMoneyMessage::Render()
+{
+	const float MAX_SCALE = 4.0f;
+	uint32 nLifeTime = CTimer::GetTimeInMilliseconds() - m_nTimeRegistered;
+	if (nLifeTime >= MONEY_MESSAGE_LIFETIME_MS) m_nTimeRegistered = 0;
+	else {
+		float fLifeTime = (float)nLifeTime / MONEY_MESSAGE_LIFETIME_MS;
+		RwV3d vecOut;
+		float fDistX, fDistY;
+		if (CSprite::CalcScreenCoors(m_vecPosition + CVector(0.0f, 0.0f, fLifeTime), &vecOut, &fDistX, &fDistY, true)) {
+			fDistX *= (0.7f * fLifeTime + 2.0f) * m_fSize;
+			fDistY *= (0.7f * fLifeTime + 2.0f) * m_fSize;
+			CFont::SetPropOn();
+			CFont::SetBackgroundOff();
+
+			float fScaleY = Min(fDistY / 100.0f, MAX_SCALE);
+			float fScaleX = Min(fDistX / 100.0f, MAX_SCALE);
+
+#ifdef FIX_BUGS
+			CFont::SetScale(SCREEN_SCALE_X(fScaleX), SCREEN_SCALE_Y(fScaleY));
+#else
+			CFont::SetScale(fScaleX, fScaleY);
+#endif
+			CFont::SetCentreOn();
+			CFont::SetCentreSize(SCREEN_WIDTH);
+			CFont::SetJustifyOff();
+			CFont::SetColor(CRGBA(m_Colour.r, m_Colour.g, m_Colour.b, (255.0f - 255.0f * fLifeTime) * m_fOpacity));
+			CFont::SetBackGroundOnlyTextOff();
+			CFont::SetFontStyle(FONT_BANK);
+			CFont::PrintString(vecOut.x, vecOut.y, m_aText);
+		}
+	}
+}
+
+void
+CMoneyMessages::Init()
+{
+	for (int32 i = 0; i < NUMMONEYMESSAGES; i++)
+		aMoneyMessages[i].m_nTimeRegistered = 0;
+}
+
+void
+CMoneyMessages::Render()
+{
+	for (int32 i = 0; i < NUMMONEYMESSAGES; i++) {
+		if (aMoneyMessages[i].m_nTimeRegistered != 0)
+			aMoneyMessages[i].Render();
+	}
+}
+
+void
+CMoneyMessages::RegisterOne(CVector vecPos, const char *pText, uint8 bRed, uint8 bGreen, uint8 bBlue, float fSize, float fOpacity)
+{
+	uint32 i;
+#ifdef FIX_BUGS
+	for(i = 0; i < NUMMONEYMESSAGES && aMoneyMessages[i].m_nTimeRegistered != 0; i++);
+#else
+	for(i = 0; aMoneyMessages[i].m_nTimeRegistered != 0 && i < NUMMONEYMESSAGES; i++);
+#endif
+
+	if(i < NUMMONEYMESSAGES) {
+		// Add data of this money message to the array
+		AsciiToUnicode(pText, aMoneyMessages[i].m_aText);
+
+		aMoneyMessages[i].m_nTimeRegistered = CTimer::GetTimeInMilliseconds();
+		aMoneyMessages[i].m_vecPosition = vecPos;
+		aMoneyMessages[i].m_Colour.red = bRed;
+		aMoneyMessages[i].m_Colour.green = bGreen;
+		aMoneyMessages[i].m_Colour.blue = bBlue;
+		aMoneyMessages[i].m_fSize = fSize;
+		aMoneyMessages[i].m_fOpacity = fOpacity;
+	}
+}
+
+CRGBA FoamColour(255, 255, 255, 255);
+uint32 CSpecialParticleStuff::BoatFromStart;
+
+void
+CSpecialParticleStuff::CreateFoamAroundObject(CMatrix* pMatrix, float innerFw, float innerRg, float innerUp, int32 particles)
+{
+	float outerFw = innerFw + 5.0f;
+	float outerRg = innerRg + 5.0f;
+	float outerUp = innerUp + 5.0f;
+	for (int attempts = 0; particles > 0 && attempts < 1000; attempts++) {
+		CVector pos;
+		int rnd = CGeneral::GetRandomNumber();
+		pos.x = (int8)(rnd - 128) * innerFw / 110.0f;
+		pos.y = (int8)((rnd >> 8) - 128) * innerFw / 110.0f;
+		pos.z = 0.0f;
+		if (DotProduct2D(pos, TheCamera.GetForward()) >= 0)
+			continue;
+		// was there any point in adding it here?
+		pos += pMatrix->GetPosition();
+		pos.z = 2.0f;
+		float fw = Abs(DotProduct(pMatrix->GetForward(), pos - pMatrix->GetPosition()));
+		if (fw >= outerFw)
+			continue;
+		float rg = Abs(DotProduct(pMatrix->GetRight(), pos - pMatrix->GetPosition()));
+		if (rg >= outerRg)
+			continue;
+		float up = Abs(DotProduct(pMatrix->GetUp(), pos - pMatrix->GetPosition()));
+		if (up >= outerUp)
+			continue;
+		if (fw > innerFw || rg > innerRg || up > innerUp) {
+			CParticle::AddParticle(PARTICLE_STEAM2, pos, CVector(0.0f, 0.0f, 0.0f), nil, 4.0f, FoamColour, 1, 0, 0, 0);
+			particles--;
+		}
+	}
+}
+
+void
+CSpecialParticleStuff::StartBoatFoamAnimation()
+{
+	BoatFromStart = CTimer::GetTimeInMilliseconds();
+}
+
+void
+CSpecialParticleStuff::UpdateBoatFoamAnimation(CMatrix* pMatrix)
+{
+	static int32 FrameInAnimation = 0;
+	static float X, Y, Z, dX, dY, dZ;
+	CreateFoamAroundObject(pMatrix, 107.0f, 24.1f, 30.5f, 2);
+	uint32 prev = CTimer::GetPreviousTimeInMilliseconds();
+	uint32 cur = CTimer::GetTimeInMilliseconds();
+	if (FrameInAnimation != 0) {
+		X += dX;
+		Y += dY;
+		Z += dZ;
+		CVector pos = *pMatrix * CVector(X, Y, Z);
+		CParticle::AddParticle(PARTICLE_STEAM_NY, pos, CVector(0.0f, 0.0f, 0.0f),
+			nil, FrameInAnimation * 0.5f + 2.0f, FoamColour, 1, 0, 0, 0);
+		if (++FrameInAnimation > 15)
+			FrameInAnimation = 0;
+	}
+	if ((cur & 0x3FF) < (prev & 0x3FF)) {
+		FrameInAnimation = 1;
+		int rnd = CGeneral::GetRandomNumber();
+		X = (int8)(rnd - 128) * 0.2f;
+		Y = (int8)((rnd >> 8) - 128) * 0.2f;
+		Z = 10.0f;
+		rnd = CGeneral::GetRandomNumber();
+		dX = (int8)(rnd - 128) * 0.02f;
+		dY = (int8)((rnd >> 8) - 128) * 0.02f;
+		dZ = 2.0f;
+	}
+}
diff --git a/src/renderer/SpecialFX.h b/src/renderer/SpecialFX.h
new file mode 100644
index 00000000..2d9f18b1
--- /dev/null
+++ b/src/renderer/SpecialFX.h
@@ -0,0 +1,224 @@
+#pragma once
+
+class CSpecialFX
+{
+public:
+	static void Render(void);
+	static void Update(void);
+	static void Init(void);
+	static void Shutdown(void);
+};
+
+class CRegisteredMotionBlurStreak
+{
+public:
+	uintptr m_id;
+	uint8 m_red;
+	uint8 m_green;
+	uint8 m_blue;
+	CVector m_pos1[3];
+	CVector m_pos2[3];
+	bool m_isValid[3];
+
+	void Update(void);
+	void Render(void);
+};
+
+class CMotionBlurStreaks
+{
+	static CRegisteredMotionBlurStreak aStreaks[NUMMBLURSTREAKS];
+public:
+	static void Init(void);
+	static void Update(void);
+	static void RegisterStreak(uintptr id, uint8 r, uint8 g, uint8 b, CVector p1, CVector p2);
+	static void Render(void);
+};
+
+struct CBulletTrace
+{
+	CVector m_vecCurrentPos;
+	CVector m_vecTargetPos;
+	bool m_bInUse;
+	uint8 m_framesInUse;
+	uint8 m_lifeTime;
+
+	void Update(void);
+};
+
+class CBulletTraces
+{
+public:
+	static CBulletTrace aTraces[NUMBULLETTRACES];
+
+	static void Init(void);
+	static void AddTrace(CVector*, CVector*);
+	static void Render(void);
+	static void Update(void);
+};
+
+enum
+{
+	MARKERTYPE_0 = 0,
+	MARKERTYPE_ARROW,
+	MARKERTYPE_2,
+	MARKERTYPE_3,
+	MARKERTYPE_CYLINDER,
+	NUMMARKERTYPES,
+
+	MARKERTYPE_INVALID = 0x101
+};
+
+
+class C3dMarker
+{
+public:
+	CMatrix m_Matrix;
+	RpAtomic *m_pAtomic;
+	RpMaterial *m_pMaterial;
+	uint16 m_nType;
+	bool m_bIsUsed;
+	uint32 m_nIdentifier;
+	RwRGBA m_Color;
+	uint16 m_nPulsePeriod;
+	int16 m_nRotateRate;
+	uint32 m_nStartTime;
+	float m_fPulseFraction;
+	float m_fStdSize;
+	float m_fSize;
+	float m_fBrightness;
+	float m_fCameraRange;
+
+	bool AddMarker(uint32 identifier, uint16 type, float fSize, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate);
+	void DeleteMarkerObject();
+	void Render();
+};
+
+class C3dMarkers
+{
+public:
+	static void Init();
+	static void Shutdown();
+	static C3dMarker *PlaceMarker(uint32 id, uint16 type, CVector &pos, float size, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate);
+	static void PlaceMarkerSet(uint32 id, uint16 type, CVector &pos, float size, uint8 r, uint8 g, uint8 b, uint8 a, uint16 pulsePeriod, float pulseFraction, int16 rotateRate);
+	static void Render();
+	static void Update();
+
+	static C3dMarker m_aMarkerArray[NUM3DMARKERS];
+	static int32 NumActiveMarkers;
+	static RpClump* m_pRpClumpArray[NUMMARKERTYPES];
+};
+
+enum
+{
+	BRIGHTLIGHT_INVALID,
+	BRIGHTLIGHT_TRAFFIC_GREEN,
+	BRIGHTLIGHT_TRAFFIC_YELLOW,
+	BRIGHTLIGHT_TRAFFIC_RED,
+
+	// white
+	BRIGHTLIGHT_FRONT_LONG,
+	BRIGHTLIGHT_FRONT_SMALL,
+	BRIGHTLIGHT_FRONT_BIG,
+	BRIGHTLIGHT_FRONT_TALL,
+
+	// red
+	BRIGHTLIGHT_REAR_LONG,
+	BRIGHTLIGHT_REAR_SMALL,
+	BRIGHTLIGHT_REAR_BIG,
+	BRIGHTLIGHT_REAR_TALL,
+
+	BRIGHTLIGHT_SIREN,	// unused
+
+	BRIGHTLIGHT_FRONT = BRIGHTLIGHT_FRONT_LONG,
+	BRIGHTLIGHT_REAR = BRIGHTLIGHT_REAR_LONG,
+};
+
+class CBrightLight
+{
+public:
+	CVector m_pos;
+	CVector m_up;
+	CVector m_side;
+	CVector m_front;
+	float m_camDist;
+	uint8 m_type;
+	uint8 m_red;
+	uint8 m_green;
+	uint8 m_blue;
+};
+
+class CBrightLights
+{
+	static int NumBrightLights;
+	static CBrightLight aBrightLights[NUMBRIGHTLIGHTS];
+public:
+	static void Init(void);
+	static void RegisterOne(CVector pos, CVector up, CVector side, CVector front,
+		uint8 type, uint8 red = 0, uint8 green = 0, uint8 blue = 0);
+	static void Render(void);
+	static void RenderOutGeometryBuffer(void);
+};
+
+
+enum
+{
+	SHINYTEXT_WALK = 1,
+	SHINYTEXT_FLAT
+};
+
+class CShinyText
+{
+public:
+	CVector m_verts[4];
+	CVector2D m_texCoords[4];
+	float m_camDist;
+	uint8 m_type;
+	uint8 m_red;
+	uint8 m_green;
+	uint8 m_blue;
+};
+
+class CShinyTexts
+{
+	static int NumShinyTexts;
+	static CShinyText aShinyTexts[NUMSHINYTEXTS];
+public:
+	static void Init(void);
+	static void RegisterOne(CVector p0, CVector p1, CVector p2, CVector p3,
+		float u0, float v0, float u1, float v1, float u2, float v2, float u3, float v3,
+		uint8 type, uint8 red, uint8 green, uint8 blue, float maxDist);
+	static void Render(void);
+	static void RenderOutGeometryBuffer(void);
+};
+
+class CMoneyMessage
+{
+	friend class CMoneyMessages;
+
+	uint32	m_nTimeRegistered;
+	CVector	m_vecPosition;
+	wchar	m_aText[16];
+	CRGBA	m_Colour;
+	float	m_fSize;
+	float	m_fOpacity;
+public:
+	void Render();
+};
+
+class CMoneyMessages
+{
+	static CMoneyMessage aMoneyMessages[NUMMONEYMESSAGES];
+public:
+	static void Init();
+	static void Render();
+	static void	RegisterOne(CVector vecPos, const char *pText, uint8 bRed, uint8 bGreen, uint8 bBlue, float fSize, float fOpacity);
+};
+
+class CSpecialParticleStuff
+{
+	static uint32 BoatFromStart;
+public:
+	static void CreateFoamAroundObject(CMatrix*, float, float, float, int32);
+	static void StartBoatFoamAnimation();
+	static void UpdateBoatFoamAnimation(CMatrix*);
+};
diff --git a/src/renderer/Sprite.cpp b/src/renderer/Sprite.cpp
new file mode 100644
index 00000000..3fef0733
--- /dev/null
+++ b/src/renderer/Sprite.cpp
@@ -0,0 +1,603 @@
+#include "common.h"
+
+#include "main.h"
+#include "Draw.h"
+#include "Camera.h"
+#include "Sprite.h"
+
+#ifdef ASPECT_RATIO_SCALE
+#include "Frontend.h"
+#endif
+
+float CSprite::m_f2DNearScreenZ;
+float CSprite::m_f2DFarScreenZ;
+float CSprite::m_fRecipNearClipPlane;
+int32 CSprite::m_bFlushSpriteBufferSwitchZTest;
+
+float 
+CSprite::CalcHorizonCoors(void)
+{
+	CVector p = TheCamera.GetPosition() + CVector(TheCamera.CamFrontXNorm, TheCamera.CamFrontYNorm, 0.0f)*3000.0f;
+	p.z = 0.0f;
+	p = TheCamera.m_viewMatrix * p;
+	return p.y * SCREEN_HEIGHT / p.z;
+}
+
+bool 
+CSprite::CalcScreenCoors(const RwV3d &in, RwV3d *out, float *outw, float *outh, bool farclip)
+{
+	CVector viewvec = TheCamera.m_viewMatrix * in;
+	*out = viewvec;
+	if(out->z <= CDraw::GetNearClipZ() + 1.0f) return false;
+	if(out->z >= CDraw::GetFarClipZ() && farclip) return false;
+	float recip = 1.0f/out->z;
+	out->x *= SCREEN_WIDTH * recip;
+	out->y *= SCREEN_HEIGHT * recip;
+	const float fov = DefaultFOV;
+	// this is used to scale correctly if you zoom in with sniper rifle
+	float fovScale = fov / CDraw::GetFOV();
+
+#ifdef FIX_SPRITES
+	*outw = CDraw::ms_bFixSprites ? (fovScale * recip * SCREEN_HEIGHT) : (fovScale * SCREEN_SCALE_AR(recip) * SCREEN_WIDTH);
+#else
+	*outw = fovScale * SCREEN_SCALE_AR(recip) * SCREEN_WIDTH;
+#endif
+	*outh = fovScale * recip * SCREEN_HEIGHT;
+
+	return true;
+}
+
+#define SPRITEBUFFERSIZE 64
+static int32 nSpriteBufferIndex;
+static RwIm2DVertex SpriteBufferVerts[SPRITEBUFFERSIZE*6];
+static RwIm2DVertex verts[4];
+
+void
+CSprite::InitSpriteBuffer(void)
+{
+	m_f2DNearScreenZ = RwIm2DGetNearScreenZ();
+	m_f2DFarScreenZ = RwIm2DGetFarScreenZ();
+}
+
+void
+CSprite::InitSpriteBuffer2D(void)
+{
+	m_fRecipNearClipPlane = 1.0f / RwCameraGetNearClipPlane(Scene.camera);
+	InitSpriteBuffer();
+}
+
+void
+CSprite::FlushSpriteBuffer(void)
+{
+	if(nSpriteBufferIndex > 0){
+		if(m_bFlushSpriteBufferSwitchZTest){
+			RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+			RwIm2DRenderPrimitive(rwPRIMTYPETRILIST, SpriteBufferVerts, nSpriteBufferIndex*6);
+			RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+		}else
+			RwIm2DRenderPrimitive(rwPRIMTYPETRILIST, SpriteBufferVerts, nSpriteBufferIndex*6);
+		nSpriteBufferIndex = 0;
+	}
+}
+
+void
+CSprite::RenderOneXLUSprite(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, uint8 a)
+{
+	static short indices[] = { 0, 1, 2, 3 };
+	// 0---3
+	// |   |
+	// 1---2
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	int i;
+
+	xs[0] = x-w;	us[0] = 0.0f;
+	xs[1] = x-w;	us[1] = 0.0f;
+	xs[2] = x+w;	us[2] = 1.0f;
+	xs[3] = x+w;	us[3] = 1.0f;
+
+	ys[0] = y-h;	vs[0] = 0.0f;
+	ys[1] = y+h;	vs[1] = 1.0f;
+	ys[2] = y+h;	vs[2] = 1.0f;
+	ys[3] = y-h;	vs[3] = 0.0f;
+
+	// clip
+	for(i = 0; i < 4; i++){
+		if(xs[i] < 0.0f){
+			us[i] = -xs[i] / (2.0f*w);
+			xs[i] = 0.0f;
+		}
+		if(xs[i] > SCREEN_WIDTH){
+			us[i] = 1.0f - (xs[i]-SCREEN_WIDTH) / (2.0f*w);
+			xs[i] = SCREEN_WIDTH;
+		}
+		if(ys[i] < 0.0f){
+			vs[i] = -ys[i] / (2.0f*h);
+			ys[i] = 0.0f;
+		}
+		if(ys[i] > SCREEN_HEIGHT){
+			vs[i] = 1.0f - (ys[i]-SCREEN_HEIGHT) / (2.0f*h);
+			ys[i] = SCREEN_HEIGHT;
+		}
+	}
+
+	// (DrawZ - DrawNear)/(DrawFar - DrawNear) = (SpriteZ-SpriteNear)/(SpriteFar-SpriteNear)
+	// So to calculate SpriteZ:
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	for(i = 0; i < 4; i++){
+		RwIm2DVertexSetScreenX(&verts[i], xs[i]);
+		RwIm2DVertexSetScreenY(&verts[i], ys[i]);
+		RwIm2DVertexSetScreenZ(&verts[i], screenz);
+		RwIm2DVertexSetCameraZ(&verts[i], z);
+		RwIm2DVertexSetRecipCameraZ(&verts[i], recipz);
+		RwIm2DVertexSetIntRGBA(&verts[i], r*intens>>8, g*intens>>8, b*intens>>8, a);
+		RwIm2DVertexSetU(&verts[i], us[i], recipz);
+		RwIm2DVertexSetV(&verts[i], vs[i], recipz);
+	}
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, verts, 4);
+}
+
+void
+CSprite::RenderOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float rotation, uint8 a)
+{
+	float c = Cos(rotation);
+	float s = Sin(rotation);
+
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	int i;
+
+	// Fade out when too near
+	// why not in buffered version?
+	if(z < 3.0f){
+		if(z < 1.5f)
+			return;
+		int f = (z - 1.5f)/1.5f * 255;
+		r = f*r >> 8;
+		g = f*g >> 8;
+		b = f*b >> 8;
+		intens = f*intens >> 8;
+	}
+
+	xs[0] = x + w*(-c-s);	us[0] = 0.0f;
+	xs[1] = x + w*(-c+s);	us[1] = 0.0f;
+	xs[2] = x + w*(+c+s);	us[2] = 1.0f;
+	xs[3] = x + w*(+c-s);	us[3] = 1.0f;
+
+	ys[0] = y + h*(-c+s);	vs[0] = 0.0f;
+	ys[1] = y + h*(+c+s);	vs[1] = 1.0f;
+	ys[2] = y + h*(+c-s);	vs[2] = 1.0f;
+	ys[3] = y + h*(-c-s);	vs[3] = 0.0f;
+
+	// No clipping, just culling
+	if(xs[0] < 0.0f && xs[1] < 0.0f && xs[2] < 0.0f && xs[3] < 0.0f) return;
+	if(ys[0] < 0.0f && ys[1] < 0.0f && ys[2] < 0.0f && ys[3] < 0.0f) return;
+	if(xs[0] > SCREEN_WIDTH && xs[1] > SCREEN_WIDTH &&
+	   xs[2] > SCREEN_WIDTH && xs[3] > SCREEN_WIDTH) return;
+	if(ys[0] > SCREEN_HEIGHT && ys[1] > SCREEN_HEIGHT &&
+	   ys[2] > SCREEN_HEIGHT && ys[3] > SCREEN_HEIGHT) return;
+
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	for(i = 0; i < 4; i++){
+		RwIm2DVertexSetScreenX(&verts[i], xs[i]);
+		RwIm2DVertexSetScreenY(&verts[i], ys[i]);
+		RwIm2DVertexSetScreenZ(&verts[i], screenz);
+		RwIm2DVertexSetCameraZ(&verts[i], z);
+		RwIm2DVertexSetRecipCameraZ(&verts[i], recipz);
+		RwIm2DVertexSetIntRGBA(&verts[i], r*intens>>8, g*intens>>8, b*intens>>8, a);
+		RwIm2DVertexSetU(&verts[i], us[i], recipz);
+		RwIm2DVertexSetV(&verts[i], vs[i], recipz);
+	}
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, verts, 4);
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, uint8 a)
+{
+	m_bFlushSpriteBufferSwitchZTest = 0;
+
+	// 0---3
+	// |   |
+	// 1---2
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	int i;
+
+	xs[0] = x-w;	us[0] = 0.0f;
+	xs[1] = x-w;	us[1] = 0.0f;
+	xs[2] = x+w;	us[2] = 1.0f;
+	xs[3] = x+w;	us[3] = 1.0f;
+
+	ys[0] = y-h;	vs[0] = 0.0f;
+	ys[1] = y+h;	vs[1] = 1.0f;
+	ys[2] = y+h;	vs[2] = 1.0f;
+	ys[3] = y-h;	vs[3] = 0.0f;
+
+	// clip
+	for(i = 0; i < 4; i++){
+		if(xs[i] < 0.0f){
+			us[i] = -xs[i] / (2.0f*w);
+			xs[i] = 0.0f;
+		}
+		if(xs[i] > SCREEN_WIDTH){
+			us[i] = 1.0f - (xs[i]-SCREEN_WIDTH) / (2.0f*w);
+			xs[i] = SCREEN_WIDTH;
+		}
+		if(ys[i] < 0.0f){
+			vs[i] = -ys[i] / (2.0f*h);
+			ys[i] = 0.0f;
+		}
+		if(ys[i] > SCREEN_HEIGHT){
+			vs[i] = 1.0f - (ys[i]-SCREEN_HEIGHT) / (2.0f*h);
+			ys[i] = SCREEN_HEIGHT;
+		}
+	}
+
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	RwIm2DVertex *vert = &SpriteBufferVerts[nSpriteBufferIndex*6];
+	static int indices[6] = { 0, 1, 2, 3, 0, 2 };
+	for(i = 0; i < 6; i++){
+		RwIm2DVertexSetScreenX(&vert[i], xs[indices[i]]);
+		RwIm2DVertexSetScreenY(&vert[i], ys[indices[i]]);
+		RwIm2DVertexSetScreenZ(&vert[i], screenz);
+		RwIm2DVertexSetCameraZ(&vert[i], z);
+		RwIm2DVertexSetRecipCameraZ(&vert[i], recipz);
+		RwIm2DVertexSetIntRGBA(&vert[i], r*intens>>8, g*intens>>8, b*intens>>8, a);
+		RwIm2DVertexSetU(&vert[i], us[indices[i]], recipz);
+		RwIm2DVertexSetV(&vert[i], vs[indices[i]], recipz);
+	}
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite_Rotate_Dimension(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float rotation, uint8 a)
+{
+	m_bFlushSpriteBufferSwitchZTest = 0;
+	// TODO: replace with lookup
+	float c = Cos(DEGTORAD(rotation));
+	float s = Sin(DEGTORAD(rotation));
+
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	int i;
+
+	xs[0] = x - c*w - s*h;	us[0] = 0.0f;
+	xs[1] = x - c*w + s*h;	us[1] = 0.0f;
+	xs[2] = x + c*w + s*h;	us[2] = 1.0f;
+	xs[3] = x + c*w - s*h;	us[3] = 1.0f;
+
+	ys[0] = y - c*h + s*w;	vs[0] = 0.0f;
+	ys[1] = y + c*h + s*w;	vs[1] = 1.0f;
+	ys[2] = y + c*h - s*w;	vs[2] = 1.0f;
+	ys[3] = y - c*h - s*w;	vs[3] = 0.0f;
+
+	// No clipping, just culling
+	if(xs[0] < 0.0f && xs[1] < 0.0f && xs[2] < 0.0f && xs[3] < 0.0f) return;
+	if(ys[0] < 0.0f && ys[1] < 0.0f && ys[2] < 0.0f && ys[3] < 0.0f) return;
+	if(xs[0] > SCREEN_WIDTH && xs[1] > SCREEN_WIDTH &&
+	   xs[2] > SCREEN_WIDTH && xs[3] > SCREEN_WIDTH) return;
+	if(ys[0] > SCREEN_HEIGHT && ys[1] > SCREEN_HEIGHT &&
+	   ys[2] > SCREEN_HEIGHT && ys[3] > SCREEN_HEIGHT) return;
+
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	RwIm2DVertex *vert = &SpriteBufferVerts[nSpriteBufferIndex*6];
+	static int indices[6] = { 0, 1, 2, 3, 0, 2 };
+	for(i = 0; i < 6; i++){
+		RwIm2DVertexSetScreenX(&vert[i], xs[indices[i]]);
+		RwIm2DVertexSetScreenY(&vert[i], ys[indices[i]]);
+		RwIm2DVertexSetScreenZ(&vert[i], screenz);
+		RwIm2DVertexSetCameraZ(&vert[i], z);
+		RwIm2DVertexSetRecipCameraZ(&vert[i], recipz);
+		RwIm2DVertexSetIntRGBA(&vert[i], r*intens>>8, g*intens>>8, b*intens>>8, a);
+		RwIm2DVertexSetU(&vert[i], us[indices[i]], recipz);
+		RwIm2DVertexSetV(&vert[i], vs[indices[i]], recipz);
+	}
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float rotation, uint8 a)
+{
+	m_bFlushSpriteBufferSwitchZTest = 0;
+	float c = Cos(rotation);
+	float s = Sin(rotation);
+
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	int i;
+
+	xs[0] = x + w*(-c-s);	us[0] = 0.0f;
+	xs[1] = x + w*(-c+s);	us[1] = 0.0f;
+	xs[2] = x + w*(+c+s);	us[2] = 1.0f;
+	xs[3] = x + w*(+c-s);	us[3] = 1.0f;
+
+	ys[0] = y + h*(-c+s);	vs[0] = 0.0f;
+	ys[1] = y + h*(+c+s);	vs[1] = 1.0f;
+	ys[2] = y + h*(+c-s);	vs[2] = 1.0f;
+	ys[3] = y + h*(-c-s);	vs[3] = 0.0f;
+
+	// No clipping, just culling
+	if(xs[0] < 0.0f && xs[1] < 0.0f && xs[2] < 0.0f && xs[3] < 0.0f) return;
+	if(ys[0] < 0.0f && ys[1] < 0.0f && ys[2] < 0.0f && ys[3] < 0.0f) return;
+	if(xs[0] > SCREEN_WIDTH && xs[1] > SCREEN_WIDTH &&
+	   xs[2] > SCREEN_WIDTH && xs[3] > SCREEN_WIDTH) return;
+	if(ys[0] > SCREEN_HEIGHT && ys[1] > SCREEN_HEIGHT &&
+	   ys[2] > SCREEN_HEIGHT && ys[3] > SCREEN_HEIGHT) return;
+
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	RwIm2DVertex *vert = &SpriteBufferVerts[nSpriteBufferIndex*6];
+	static int indices[6] = { 0, 1, 2, 3, 0, 2 };
+	for(i = 0; i < 6; i++){
+		RwIm2DVertexSetScreenX(&vert[i], xs[indices[i]]);
+		RwIm2DVertexSetScreenY(&vert[i], ys[indices[i]]);
+		RwIm2DVertexSetScreenZ(&vert[i], screenz);
+		RwIm2DVertexSetCameraZ(&vert[i], z);
+		RwIm2DVertexSetRecipCameraZ(&vert[i], recipz);
+		RwIm2DVertexSetIntRGBA(&vert[i], r*intens>>8, g*intens>>8, b*intens>>8, a);
+		RwIm2DVertexSetU(&vert[i], us[indices[i]], recipz);
+		RwIm2DVertexSetV(&vert[i], vs[indices[i]], recipz);
+	}
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite_Rotate_2Colours(float x, float y, float z, float w, float h, uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2, float cx, float cy, float recipz, float rotation, uint8 a)
+{
+	m_bFlushSpriteBufferSwitchZTest = 0;
+	float c = Cos(rotation);
+	float s = Sin(rotation);
+
+	float xs[4];
+	float ys[4];
+	float us[4];
+	float vs[4];
+	float cf[4];
+	int i;
+
+	xs[0] = x + w*(-c-s);	us[0] = 0.0f;
+	xs[1] = x + w*(-c+s);	us[1] = 0.0f;
+	xs[2] = x + w*(+c+s);	us[2] = 1.0f;
+	xs[3] = x + w*(+c-s);	us[3] = 1.0f;
+
+	ys[0] = y + h*(-c+s);	vs[0] = 0.0f;
+	ys[1] = y + h*(+c+s);	vs[1] = 1.0f;
+	ys[2] = y + h*(+c-s);	vs[2] = 1.0f;
+	ys[3] = y + h*(-c-s);	vs[3] = 0.0f;
+
+	// No clipping, just culling
+	if(xs[0] < 0.0f && xs[1] < 0.0f && xs[2] < 0.0f && xs[3] < 0.0f) return;
+	if(ys[0] < 0.0f && ys[1] < 0.0f && ys[2] < 0.0f && ys[3] < 0.0f) return;
+	if(xs[0] > SCREEN_WIDTH && xs[1] > SCREEN_WIDTH &&
+	   xs[2] > SCREEN_WIDTH && xs[3] > SCREEN_WIDTH) return;
+	if(ys[0] > SCREEN_HEIGHT && ys[1] > SCREEN_HEIGHT &&
+	   ys[2] > SCREEN_HEIGHT && ys[3] > SCREEN_HEIGHT) return;
+
+	// Colour factors, cx/y is the direction in which colours change from rgb1 to rgb2
+	cf[0] = (cx*(-c-s) + cy*(-c+s))*0.5f + 0.5f;
+	cf[0] = Clamp(cf[0], 0.0f, 1.0f);
+	cf[1] = (cx*(-c+s) + cy*( c+s))*0.5f + 0.5f;
+	cf[1] = Clamp(cf[1], 0.0f, 1.0f);
+	cf[2] = (cx*( c+s) + cy*( c-s))*0.5f + 0.5f;
+	cf[2] = Clamp(cf[2], 0.0f, 1.0f);
+	cf[3] = (cx*( c-s) + cy*(-c-s))*0.5f + 0.5f;
+	cf[3] = Clamp(cf[3], 0.0f, 1.0f);
+
+	float screenz = m_f2DNearScreenZ +
+		(z-CDraw::GetNearClipZ())*(m_f2DFarScreenZ-m_f2DNearScreenZ)*CDraw::GetFarClipZ() /
+		((CDraw::GetFarClipZ()-CDraw::GetNearClipZ())*z);
+
+	RwIm2DVertex *vert = &SpriteBufferVerts[nSpriteBufferIndex*6];
+	static int indices[6] = { 0, 1, 2, 3, 0, 2 };
+	for(i = 0; i < 6; i++){
+		RwIm2DVertexSetScreenX(&vert[i], xs[indices[i]]);
+		RwIm2DVertexSetScreenY(&vert[i], ys[indices[i]]);
+		RwIm2DVertexSetScreenZ(&vert[i], screenz);
+		RwIm2DVertexSetCameraZ(&vert[i], z);
+		RwIm2DVertexSetRecipCameraZ(&vert[i], recipz);
+		RwIm2DVertexSetIntRGBA(&vert[i],
+			r1*cf[indices[i]] + r2*(1.0f - cf[indices[i]]),
+			g1*cf[indices[i]] + g2*(1.0f - cf[indices[i]]),
+			b1*cf[indices[i]] + b2*(1.0f - cf[indices[i]]),
+			a);
+		RwIm2DVertexSetU(&vert[i], us[indices[i]], recipz);
+		RwIm2DVertexSetV(&vert[i], vs[indices[i]], recipz);
+	}
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
+
+void
+CSprite::Set6Vertices2D(RwIm2DVertex *verts, const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	float screenz, recipz;
+	float z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+	screenz = m_f2DNearScreenZ;
+	recipz = m_fRecipNearClipPlane;
+
+	RwIm2DVertexSetScreenX(&verts[0], r.left);
+	RwIm2DVertexSetScreenY(&verts[0], r.top);
+	RwIm2DVertexSetScreenZ(&verts[0], screenz);
+	RwIm2DVertexSetCameraZ(&verts[0], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[0], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[0], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[0], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[1], r.right);
+	RwIm2DVertexSetScreenY(&verts[1], r.top);
+	RwIm2DVertexSetScreenZ(&verts[1], screenz);
+	RwIm2DVertexSetCameraZ(&verts[1], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[1], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[1], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&verts[1], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[1], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[2], r.right);
+	RwIm2DVertexSetScreenY(&verts[2], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[2], screenz);
+	RwIm2DVertexSetCameraZ(&verts[2], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[2], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[2], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[2], 1.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[3], r.left);
+	RwIm2DVertexSetScreenY(&verts[3], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[3], screenz);
+	RwIm2DVertexSetCameraZ(&verts[3], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[3], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[3], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&verts[3], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[3], 1.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[4], r.left);
+	RwIm2DVertexSetScreenY(&verts[4], r.top);
+	RwIm2DVertexSetScreenZ(&verts[4], screenz);
+	RwIm2DVertexSetCameraZ(&verts[4], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[4], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[4], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[4], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[4], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[5], r.right);
+	RwIm2DVertexSetScreenY(&verts[5], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[5], screenz);
+	RwIm2DVertexSetCameraZ(&verts[5], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[5], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[5], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[5], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[5], 1.0f, recipz);
+}
+
+void
+CSprite::Set6Vertices2D(RwIm2DVertex *verts, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
+		const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	float screenz, recipz;
+	float z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+	screenz = m_f2DNearScreenZ;
+	recipz = m_fRecipNearClipPlane;
+
+	RwIm2DVertexSetScreenX(&verts[0], x3);
+	RwIm2DVertexSetScreenY(&verts[0], y3);
+	RwIm2DVertexSetScreenZ(&verts[0], screenz);
+	RwIm2DVertexSetCameraZ(&verts[0], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[0], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[0], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[0], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[1], x4);
+	RwIm2DVertexSetScreenY(&verts[1], y4);
+	RwIm2DVertexSetScreenZ(&verts[1], screenz);
+	RwIm2DVertexSetCameraZ(&verts[1], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[1], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[1], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&verts[1], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[1], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[2], x2);
+	RwIm2DVertexSetScreenY(&verts[2], y2);
+	RwIm2DVertexSetScreenZ(&verts[2], screenz);
+	RwIm2DVertexSetCameraZ(&verts[2], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[2], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[2], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[2], 1.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[3], x1);
+	RwIm2DVertexSetScreenY(&verts[3], y1);
+	RwIm2DVertexSetScreenZ(&verts[3], screenz);
+	RwIm2DVertexSetCameraZ(&verts[3], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[3], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[3], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&verts[3], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[3], 1.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[4], x3);
+	RwIm2DVertexSetScreenY(&verts[4], y3);
+	RwIm2DVertexSetScreenZ(&verts[4], screenz);
+	RwIm2DVertexSetCameraZ(&verts[4], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[4], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[4], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[4], 0.0f, recipz);
+	RwIm2DVertexSetV(&verts[4], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[5], x2);
+	RwIm2DVertexSetScreenY(&verts[5], y2);
+	RwIm2DVertexSetScreenZ(&verts[5], screenz);
+	RwIm2DVertexSetCameraZ(&verts[5], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[5], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[5], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[5], 1.0f, recipz);
+	RwIm2DVertexSetV(&verts[5], 1.0f, recipz);
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite2D(float x, float y, float w, float h, const RwRGBA &colour, int16 intens, uint8 alpha)
+{
+	m_bFlushSpriteBufferSwitchZTest = 1;
+	CRGBA col(intens * colour.red >> 8, intens * colour.green >> 8, intens * colour.blue >> 8, alpha);
+	CRect rect(x - w, y - h, x + h, y + h);
+	Set6Vertices2D(&SpriteBufferVerts[6 * nSpriteBufferIndex], rect, col, col, col, col);
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
+
+void
+CSprite::RenderBufferedOneXLUSprite2D_Rotate_Dimension(float x, float y, float w, float h, const RwRGBA &colour, int16 intens, float rotation, uint8 alpha)
+{
+	m_bFlushSpriteBufferSwitchZTest = 1;
+	CRGBA col(intens * colour.red >> 8, intens * colour.green >> 8, intens * colour.blue >> 8, alpha);
+	float c = Cos(DEGTORAD(rotation));
+	float s = Sin(DEGTORAD(rotation));
+
+	Set6Vertices2D(&SpriteBufferVerts[6 * nSpriteBufferIndex],
+		x + c*w - s*h,
+		y - c*h - s*w,
+		x + c*w + s*h,
+		y + c*h - s*w,
+		x - c*w - s*h,
+		y - c*h + s*w,
+		x - c*w + s*h,
+		y + c*h + s*w,
+		col, col, col, col);
+	nSpriteBufferIndex++;
+	if(nSpriteBufferIndex >= SPRITEBUFFERSIZE)
+		FlushSpriteBuffer();
+}
diff --git a/src/renderer/Sprite.h b/src/renderer/Sprite.h
new file mode 100644
index 00000000..ec4c1d1b
--- /dev/null
+++ b/src/renderer/Sprite.h
@@ -0,0 +1,28 @@
+#pragma once
+
+class CSprite
+{
+	static float m_f2DNearScreenZ;
+	static float m_f2DFarScreenZ;
+	static float m_fRecipNearClipPlane;
+	static int32 m_bFlushSpriteBufferSwitchZTest;
+public:
+	static float CalcHorizonCoors(void);
+	static bool CalcScreenCoors(const RwV3d &in, RwV3d *out, float *outw, float *outh, bool farclip);
+	static void InitSpriteBuffer(void);
+	static void InitSpriteBuffer2D(void);
+	static void FlushSpriteBuffer(void);
+	static void RenderOneXLUSprite(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, uint8 a);
+	static void RenderOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float roll, uint8 a);
+	static void RenderBufferedOneXLUSprite(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, uint8 a);
+	static void RenderBufferedOneXLUSprite_Rotate_Dimension(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float roll, uint8 a);
+	static void RenderBufferedOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float roll, uint8 a);
+	// cx/y is the direction in which the colour changes
+	static void RenderBufferedOneXLUSprite_Rotate_2Colours(float x, float y, float z, float w, float h, uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2, float cx, float cy, float recipz, float rotation, uint8 a);
+	static void Set6Vertices2D(RwIm2DVertex *verts, const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+	static void Set6Vertices2D(RwIm2DVertex *verts, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
+		const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+	static void RenderBufferedOneXLUSprite2D(float x, float y, float w, float h, const RwRGBA &colour, int16 intens, uint8 alpha);
+	static void RenderBufferedOneXLUSprite2D_Rotate_Dimension(float x, float y, float w, float h, const RwRGBA &colour, int16 intens, float rotation, uint8 alpha);
+
+};
diff --git a/src/renderer/Sprite2d.cpp b/src/renderer/Sprite2d.cpp
new file mode 100644
index 00000000..59622516
--- /dev/null
+++ b/src/renderer/Sprite2d.cpp
@@ -0,0 +1,490 @@
+#include "common.h"
+
+#include "main.h"
+#include "Draw.h"
+#include "Camera.h"
+#include "Sprite2d.h"
+#include "Font.h"
+
+RwIm2DVertex CSprite2d::maVertices[8];
+float CSprite2d::RecipNearClip;
+int32 CSprite2d::mCurrentBank;
+RwTexture *CSprite2d::mpBankTextures[10];
+int32 CSprite2d::mCurrentSprite[10];
+int32 CSprite2d::mBankStart[10];
+RwIm2DVertex CSprite2d::maBankVertices[500];
+
+void
+CSprite2d::SetRecipNearClip(void)
+{
+	RecipNearClip = 1.0f / RwCameraGetNearClipPlane(Scene.camera);
+}
+
+void
+CSprite2d::InitPerFrame(void)
+{
+	int i;
+
+	mCurrentBank = 0;
+	for(i = 0; i < 10; i++)
+		mCurrentSprite[i] = 0;
+#ifndef SQUEEZE_PERFORMANCE
+	for(i = 0; i < 10; i++)
+		mpBankTextures[i] = nil;
+#endif
+}
+
+int32
+CSprite2d::GetBank(int32 n, RwTexture *tex)
+{
+#ifndef SQUEEZE_PERFORMANCE
+	mpBankTextures[mCurrentBank] = tex;
+#endif
+	mCurrentSprite[mCurrentBank] = 0;
+	mBankStart[mCurrentBank+1] = mBankStart[mCurrentBank] + n;
+	return mCurrentBank++;
+}
+
+void
+CSprite2d::AddSpriteToBank(int32 bank, const CRect &rect, const CRGBA &col,
+	float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2)
+{
+	SetVertices(&maBankVertices[6 * (mCurrentSprite[bank] + mBankStart[bank])],
+		rect, col, col, col, col,
+		u0, v0, u1, v1, u2, v2, u3, v3);
+	mCurrentSprite[bank]++;
+	if(mCurrentSprite[bank] + mBankStart[bank] >= mBankStart[bank+1]){
+		DrawBank(bank);
+		mCurrentSprite[bank] = 0;
+	}
+}
+
+void
+CSprite2d::DrawBank(int32 bank)
+{
+	if(mCurrentSprite[bank] == 0)
+		return;
+#ifndef SQUEEZE_PERFORMANCE
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER,
+		mpBankTextures[bank] ? RwTextureGetRaster(mpBankTextures[bank]) : nil);
+#else
+	CFont::Sprite[bank].SetRenderState();
+#endif
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void*)rwFILTERLINEAR);
+	RwIm2DRenderPrimitive(rwPRIMTYPETRILIST, &maBankVertices[6*mBankStart[bank]], 6*mCurrentSprite[bank]);
+	mCurrentSprite[bank] = 0;
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+}
+
+
+void
+CSprite2d::Delete(void)
+{
+	if(m_pTexture){
+		RwTextureDestroy(m_pTexture);
+		m_pTexture = nil;
+	}
+}
+
+void
+CSprite2d::SetTexture(const char *name)
+{
+	Delete();
+	if(name)
+		m_pTexture = RwTextureRead(name, nil);
+}
+
+void
+CSprite2d::SetTexture(const char *name, const char *mask)
+{
+	Delete();
+	if(name)
+		m_pTexture = RwTextureRead(name, mask);
+}
+
+void
+CSprite2d::SetAddressing(RwTextureAddressMode addr)
+{
+	if(m_pTexture)
+		RwTextureSetAddressing(m_pTexture, addr);
+}
+
+void
+CSprite2d::SetRenderState(void)
+{
+	if(m_pTexture)
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(m_pTexture));
+	else
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+}
+
+void
+CSprite2d::Draw(float x, float y, float w, float h, const CRGBA &col)
+{
+	SetVertices(CRect(x, y, x + w, y + h), col, col, col, col, 0);
+	SetRenderState();
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+}
+
+void
+CSprite2d::Draw(const CRect &rect, const CRGBA &col)
+{
+	SetVertices(rect, col, col, col, col, 0);
+	SetRenderState();
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+}
+
+void
+CSprite2d::Draw(const CRect &rect, const CRGBA &col,
+	float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2)
+{
+	SetVertices(rect, col, col, col, col, u0, v0, u1, v1, u3, v3, u2, v2);
+	SetRenderState();
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+}
+
+void
+CSprite2d::Draw(const CRect &rect, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	SetVertices(rect, c0, c1, c2, c3, 0);
+	SetRenderState();
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+}
+
+void
+CSprite2d::Draw(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, const CRGBA &col)
+{
+	SetVertices(x1, y1, x2, y2, x3, y3, x4, y4, col, col, col, col);
+	SetRenderState();
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+}
+
+
+// Arguments:
+// 2---3
+// |   |
+// 0---1
+void
+CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3, uint32 far)
+{
+	float screenz, z, recipz;
+
+	if(far){
+		screenz = RwIm2DGetFarScreenZ();
+		z = RwCameraGetFarClipPlane(Scene.camera);
+	}else{
+		screenz = RwIm2DGetNearScreenZ();
+		z = 1.0f/RecipNearClip;
+	}
+	recipz = 1.0f/z;
+	float offset = 1.0f/1024.0f;
+
+	// This is what we draw:
+	// 0---1
+	// | / |
+	// 3---2
+	RwIm2DVertexSetScreenX(&maVertices[0], r.left);
+	RwIm2DVertexSetScreenY(&maVertices[0], r.top);
+	RwIm2DVertexSetScreenZ(&maVertices[0], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[0], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[0], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&maVertices[0], 0.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[0], 0.0f+offset, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[1], r.right);
+	RwIm2DVertexSetScreenY(&maVertices[1], r.top);
+	RwIm2DVertexSetScreenZ(&maVertices[1], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[1], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[1], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[1], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&maVertices[1], 1.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[1], 0.0f+offset, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[2], r.right);
+	RwIm2DVertexSetScreenY(&maVertices[2], r.bottom);
+	RwIm2DVertexSetScreenZ(&maVertices[2], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[2], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[2], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&maVertices[2], 1.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[2], 1.0f+offset, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[3], r.left);
+	RwIm2DVertexSetScreenY(&maVertices[3], r.bottom);
+	RwIm2DVertexSetScreenZ(&maVertices[3], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[3], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[3], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[3], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&maVertices[3], 0.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[3], 1.0f+offset, recipz);
+}
+
+void
+CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3,
+	float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2)
+{
+	float screenz, z, recipz;
+
+	screenz = RwIm2DGetNearScreenZ();
+	z = 1.0f/RecipNearClip;
+	recipz = 1.0f/z;
+
+	// This is what we draw:
+	// 0---1
+	// | / |
+	// 3---2
+	RwIm2DVertexSetScreenX(&maVertices[0], r.left);
+	RwIm2DVertexSetScreenY(&maVertices[0], r.top);
+	RwIm2DVertexSetScreenZ(&maVertices[0], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[0], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[0], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&maVertices[0], u0, recipz);
+	RwIm2DVertexSetV(&maVertices[0], v0, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[1], r.right);
+	RwIm2DVertexSetScreenY(&maVertices[1], r.top);
+	RwIm2DVertexSetScreenZ(&maVertices[1], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[1], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[1], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[1], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&maVertices[1], u1, recipz);
+	RwIm2DVertexSetV(&maVertices[1], v1, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[2], r.right);
+	RwIm2DVertexSetScreenY(&maVertices[2], r.bottom);
+	RwIm2DVertexSetScreenZ(&maVertices[2], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[2], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[2], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&maVertices[2], u2, recipz);
+	RwIm2DVertexSetV(&maVertices[2], v2, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[3], r.left);
+	RwIm2DVertexSetScreenY(&maVertices[3], r.bottom);
+	RwIm2DVertexSetScreenZ(&maVertices[3], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[3], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[3], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[3], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&maVertices[3], u3, recipz);
+	RwIm2DVertexSetV(&maVertices[3], v3, recipz);
+}
+
+void
+CSprite2d::SetVertices(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
+		const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	float screenz, recipz;
+	float z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+	screenz = RwIm2DGetNearScreenZ();
+	recipz = RecipNearClip;
+
+	RwIm2DVertexSetScreenX(&maVertices[0], x3);
+	RwIm2DVertexSetScreenY(&maVertices[0], y3);
+	RwIm2DVertexSetScreenZ(&maVertices[0], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[0], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[0], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&maVertices[0], 0.0f, recipz);
+	RwIm2DVertexSetV(&maVertices[0], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[1], x4);
+	RwIm2DVertexSetScreenY(&maVertices[1], y4);
+	RwIm2DVertexSetScreenZ(&maVertices[1], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[1], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[1], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[1], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&maVertices[1], 1.0f, recipz);
+	RwIm2DVertexSetV(&maVertices[1], 0.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[2], x2);
+	RwIm2DVertexSetScreenY(&maVertices[2], y2);
+	RwIm2DVertexSetScreenZ(&maVertices[2], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[2], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[2], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&maVertices[2], 1.0f, recipz);
+	RwIm2DVertexSetV(&maVertices[2], 1.0f, recipz);
+
+	RwIm2DVertexSetScreenX(&maVertices[3], x1);
+	RwIm2DVertexSetScreenY(&maVertices[3], y1);
+	RwIm2DVertexSetScreenZ(&maVertices[3], screenz);
+	RwIm2DVertexSetCameraZ(&maVertices[3], z);
+	RwIm2DVertexSetRecipCameraZ(&maVertices[3], recipz);
+	RwIm2DVertexSetIntRGBA(&maVertices[3], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&maVertices[3], 0.0f, recipz);
+	RwIm2DVertexSetV(&maVertices[3], 1.0f, recipz);
+}
+
+void
+CSprite2d::SetVertices(int n, float *positions, float *uvs, const CRGBA &col)
+{
+	int i;
+	float screenz, recipz, z;
+
+	screenz = RwIm2DGetNearScreenZ();
+	recipz = RecipNearClip;
+	z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+
+	for(i = 0; i < n; i++){
+		RwIm2DVertexSetScreenX(&maVertices[i], positions[i*2 + 0]);
+		RwIm2DVertexSetScreenY(&maVertices[i], positions[i*2 + 1]);
+		RwIm2DVertexSetScreenZ(&maVertices[i], screenz + 0.0001f);
+		RwIm2DVertexSetCameraZ(&maVertices[i], z);
+		RwIm2DVertexSetRecipCameraZ(&maVertices[i], recipz);
+		RwIm2DVertexSetIntRGBA(&maVertices[i], col.r, col.g, col.b, col.a);
+		RwIm2DVertexSetU(&maVertices[i], uvs[i*2 + 0], recipz);
+		RwIm2DVertexSetV(&maVertices[i], uvs[i*2 + 1], recipz);
+	}
+}
+
+void
+CSprite2d::SetMaskVertices(int n, float *positions)
+{
+	int i;
+	float screenz, recipz, z;
+
+	screenz = RwIm2DGetNearScreenZ();
+	recipz = RecipNearClip;
+	z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+	for(i = 0; i < n; i++){
+		RwIm2DVertexSetScreenX(&maVertices[i], positions[i*2 + 0]);
+		RwIm2DVertexSetScreenY(&maVertices[i], positions[i*2 + 1]);
+		RwIm2DVertexSetScreenZ(&maVertices[i], screenz);
+		RwIm2DVertexSetCameraZ(&maVertices[i], z);
+		RwIm2DVertexSetRecipCameraZ(&maVertices[i], recipz);
+#if !defined(GTA_PS2_STUFF) && defined(RWLIBS)
+		RwIm2DVertexSetIntRGBA(&maVertices[i], 0, 0, 0, 0);
+#else
+		RwIm2DVertexSetIntRGBA(&maVertices[i], 255, 255, 255, 255);
+#endif
+	}
+}
+
+void
+CSprite2d::SetVertices(RwIm2DVertex *verts, const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3,
+		float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2)
+{
+	float screenz, recipz, z;
+
+	screenz = RwIm2DGetNearScreenZ();
+	recipz = RecipNearClip;
+	z = RwCameraGetNearClipPlane(Scene.camera);	// not done by game
+
+	RwIm2DVertexSetScreenX(&verts[0], r.left);
+	RwIm2DVertexSetScreenY(&verts[0], r.top);
+	RwIm2DVertexSetScreenZ(&verts[0], screenz);
+	RwIm2DVertexSetCameraZ(&verts[0], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[0], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[0], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[0], u0, recipz);
+	RwIm2DVertexSetV(&verts[0], v0, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[1], r.left);
+	RwIm2DVertexSetScreenY(&verts[1], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[1], screenz);
+	RwIm2DVertexSetCameraZ(&verts[1], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[1], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[1], c0.r, c0.g, c0.b, c0.a);
+	RwIm2DVertexSetU(&verts[1], u2, recipz);
+	RwIm2DVertexSetV(&verts[1], v2, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[2], r.right);
+	RwIm2DVertexSetScreenY(&verts[2], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[2], screenz);
+	RwIm2DVertexSetCameraZ(&verts[2], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[2], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[2], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[2], u3, recipz);
+	RwIm2DVertexSetV(&verts[2], v3, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[3], r.left);
+	RwIm2DVertexSetScreenY(&verts[3], r.top);
+	RwIm2DVertexSetScreenZ(&verts[3], screenz);
+	RwIm2DVertexSetCameraZ(&verts[3], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[3], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[3], c2.r, c2.g, c2.b, c2.a);
+	RwIm2DVertexSetU(&verts[3], u0, recipz);
+	RwIm2DVertexSetV(&verts[3], v0, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[4], r.right);
+	RwIm2DVertexSetScreenY(&verts[4], r.bottom);
+	RwIm2DVertexSetScreenZ(&verts[4], screenz);
+	RwIm2DVertexSetCameraZ(&verts[4], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[4], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[4], c1.r, c1.g, c1.b, c1.a);
+	RwIm2DVertexSetU(&verts[4], u3, recipz);
+	RwIm2DVertexSetV(&verts[4], v3, recipz);
+
+	RwIm2DVertexSetScreenX(&verts[5], r.right);
+	RwIm2DVertexSetScreenY(&verts[5], r.top);
+	RwIm2DVertexSetScreenZ(&verts[5], screenz);
+	RwIm2DVertexSetCameraZ(&verts[5], z);
+	RwIm2DVertexSetRecipCameraZ(&verts[5], recipz);
+	RwIm2DVertexSetIntRGBA(&verts[5], c3.r, c3.g, c3.b, c3.a);
+	RwIm2DVertexSetU(&verts[5], u1, recipz);
+	RwIm2DVertexSetV(&verts[5], v1, recipz);
+
+}
+
+void
+CSprite2d::DrawRect(const CRect &r, const CRGBA &col)
+{
+	SetVertices(r, col, col, col, col, false);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATESHADEMODE, (void*)rwSHADEMODEFLAT);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)(col.a != 255));
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, maVertices, 4);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESHADEMODE, (void*)rwSHADEMODEGOURAUD);
+}
+
+void
+CSprite2d::DrawRect(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	SetVertices(r, c0, c1, c2, c3, false);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, maVertices, 4);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+}
+
+void
+CSprite2d::DrawRectXLU(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3)
+{
+	SetVertices(r, c0, c1, c2, c3, false);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+}
+
+void CSprite2d::Draw2DPolygon(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, const CRGBA &color)
+{
+	SetVertices(x1, y1, x2, y2, x3, y3, x4, y4, color, color, color, color);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, 0);
+	RwRenderStateSet(rwRENDERSTATESHADEMODE, (void*)rwSHADEMODEFLAT);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)(color.a != 255));
+	RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, CSprite2d::maVertices, 4);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESHADEMODE, (void*)rwSHADEMODEGOURAUD);
+}
diff --git a/src/renderer/Sprite2d.h b/src/renderer/Sprite2d.h
new file mode 100644
index 00000000..0e12d441
--- /dev/null
+++ b/src/renderer/Sprite2d.h
@@ -0,0 +1,53 @@
+#pragma once
+
+class CSprite2d
+{
+	static float RecipNearClip;
+	static int32 mCurrentBank;
+	static RwTexture *mpBankTextures[10];
+	static int32 mCurrentSprite[10];
+	static int32 mBankStart[10];
+	static RwIm2DVertex maBankVertices[500];
+	static RwIm2DVertex maVertices[8];
+public:
+	RwTexture *m_pTexture;
+
+	static void SetRecipNearClip(void);
+	static void InitPerFrame(void);
+	static int32 GetBank(int32 n, RwTexture *tex);
+	static void AddSpriteToBank(int32 bank, const CRect &rect, const CRGBA &col,
+		float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2);
+	static void DrawBank(int32 bank);
+
+	CSprite2d(void) : m_pTexture(nil) {};
+	~CSprite2d(void) { Delete(); };
+	void Delete(void);
+	void SetRenderState(void);
+	void SetTexture(const char *name);
+	void SetTexture(const char *name, const char *mask);
+	void SetAddressing(RwTextureAddressMode addr);
+	void Draw(float x, float y, float w, float h, const CRGBA &col);
+	void Draw(const CRect &rect, const CRGBA &col);
+	void Draw(const CRect &rect, const CRGBA &col,
+		float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2);
+	void Draw(const CRect &rect, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+	void Draw(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, const CRGBA &col);
+
+	static void SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3, uint32 far);
+	static void SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3,
+		float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2);
+	static void SetVertices(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
+		const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+	static void SetVertices(int n, float *positions, float *uvs, const CRGBA &col);
+	static void SetMaskVertices(int n, float *positions);
+	static void SetVertices(RwIm2DVertex *verts, const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3,
+		float u0, float v0, float u1, float v1, float u3, float v3, float u2, float v2);
+
+	static void DrawRect(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+	static void DrawRect(const CRect &r, const CRGBA &col);
+	static void DrawRectXLU(const CRect &r, const CRGBA &c0, const CRGBA &c1, const CRGBA &c2, const CRGBA &c3);
+
+	static void Draw2DPolygon(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, const CRGBA &color);
+
+	static RwIm2DVertex* GetVertices() { return maVertices; };
+};
diff --git a/src/renderer/TexList.cpp b/src/renderer/TexList.cpp
new file mode 100644
index 00000000..1689837f
--- /dev/null
+++ b/src/renderer/TexList.cpp
@@ -0,0 +1,41 @@
+#include "common.h"
+#include "TexList.h"
+#include "rtbmp.h"
+#include "FileMgr.h"
+
+bool CTexList::ms_nTexUsed[MAX_TEXUSED];
+
+void
+CTexList::Initialise()
+{}
+
+void
+CTexList::Shutdown()
+{}
+
+RwTexture *
+CTexList::SetTexture(int32 slot, char *name)
+{
+	return nil;
+}
+
+int32
+CTexList::GetFirstFreeTexture()
+{
+	for (int32 i = 0; i < MAX_TEXUSED; i++)
+		if (!ms_nTexUsed[i])
+			return i;
+	return -1;
+}
+
+RwTexture *
+CTexList::LoadFileNameTexture(char *name)
+{
+	return SetTexture(GetFirstFreeTexture(), name);
+}
+
+void
+CTexList::LoadGlobalTextureList()
+{
+	CFileMgr::SetDir("TEXTURES");
+}
\ No newline at end of file
diff --git a/src/renderer/TexList.h b/src/renderer/TexList.h
new file mode 100644
index 00000000..7e042211
--- /dev/null
+++ b/src/renderer/TexList.h
@@ -0,0 +1,14 @@
+#pragma once
+
+class CTexList
+{
+	enum { MAX_TEXUSED = 400, };
+	static bool ms_nTexUsed[MAX_TEXUSED];
+public:
+	static void Initialise();
+	static void Shutdown();
+	static RwTexture *SetTexture(int32 slot, char *name);
+	static int32 GetFirstFreeTexture();
+	static RwTexture *LoadFileNameTexture(char *name);
+	static void LoadGlobalTextureList();
+};
\ No newline at end of file
diff --git a/src/renderer/Timecycle.cpp b/src/renderer/Timecycle.cpp
new file mode 100644
index 00000000..0d94dbd6
--- /dev/null
+++ b/src/renderer/Timecycle.cpp
@@ -0,0 +1,317 @@
+#include "common.h"
+
+#include "main.h"
+#include "Clock.h"
+#include "Weather.h"
+#include "Camera.h"
+#include "Shadows.h"
+#include "ZoneCull.h"
+#include "CutsceneMgr.h"
+#include "FileMgr.h"
+#include "Timecycle.h"
+
+int32 CTimeCycle::m_nAmbientRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nAmbientGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nAmbientBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nDirectionalRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nDirectionalGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nDirectionalBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyTopRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyTopGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyTopBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyBottomRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyBottomGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSkyBottomBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoreRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoreGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoreBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoronaRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoronaGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nSunCoronaBlue[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fSunSize[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fSpriteSize[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fSpriteBrightness[NUMHOURS][NUMWEATHERS];
+int16 CTimeCycle::m_nShadowStrength[NUMHOURS][NUMWEATHERS];
+int16 CTimeCycle::m_nLightShadowStrength[NUMHOURS][NUMWEATHERS];
+int16 CTimeCycle::m_nTreeShadowStrength[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fFogStart[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fFarClip[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fLightsOnGroundBrightness[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nLowCloudsRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nLowCloudsGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nLowCloudsBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsTopRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsTopGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsTopBlue[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsBottomRed[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsBottomGreen[NUMHOURS][NUMWEATHERS];
+int32 CTimeCycle::m_nFluffyCloudsBottomBlue[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fBlurRed[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fBlurGreen[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fBlurBlue[NUMHOURS][NUMWEATHERS];
+float CTimeCycle::m_fBlurAlpha[NUMHOURS][NUMWEATHERS];
+
+float CTimeCycle::m_fCurrentAmbientRed;
+float CTimeCycle::m_fCurrentAmbientGreen;
+float CTimeCycle::m_fCurrentAmbientBlue;
+float CTimeCycle::m_fCurrentDirectionalRed;
+float CTimeCycle::m_fCurrentDirectionalGreen;
+float CTimeCycle::m_fCurrentDirectionalBlue;
+int32 CTimeCycle::m_nCurrentSkyTopRed;
+int32 CTimeCycle::m_nCurrentSkyTopGreen;
+int32 CTimeCycle::m_nCurrentSkyTopBlue;
+int32 CTimeCycle::m_nCurrentSkyBottomRed;
+int32 CTimeCycle::m_nCurrentSkyBottomGreen;
+int32 CTimeCycle::m_nCurrentSkyBottomBlue;
+int32 CTimeCycle::m_nCurrentSunCoreRed;
+int32 CTimeCycle::m_nCurrentSunCoreGreen;
+int32 CTimeCycle::m_nCurrentSunCoreBlue;
+int32 CTimeCycle::m_nCurrentSunCoronaRed;
+int32 CTimeCycle::m_nCurrentSunCoronaGreen;
+int32 CTimeCycle::m_nCurrentSunCoronaBlue;
+float CTimeCycle::m_fCurrentSunSize;
+float CTimeCycle::m_fCurrentSpriteSize;
+float CTimeCycle::m_fCurrentSpriteBrightness;
+int32 CTimeCycle::m_nCurrentShadowStrength;
+int32 CTimeCycle::m_nCurrentLightShadowStrength;
+int32 CTimeCycle::m_nCurrentTreeShadowStrength;
+float CTimeCycle::m_fCurrentFogStart;
+float CTimeCycle::m_fCurrentFarClip;
+float CTimeCycle::m_fCurrentLightsOnGroundBrightness;
+int32 CTimeCycle::m_nCurrentLowCloudsRed;
+int32 CTimeCycle::m_nCurrentLowCloudsGreen;
+int32 CTimeCycle::m_nCurrentLowCloudsBlue;
+int32 CTimeCycle::m_nCurrentFluffyCloudsTopRed;
+int32 CTimeCycle::m_nCurrentFluffyCloudsTopGreen;
+int32 CTimeCycle::m_nCurrentFluffyCloudsTopBlue;
+int32 CTimeCycle::m_nCurrentFluffyCloudsBottomRed;
+int32 CTimeCycle::m_nCurrentFluffyCloudsBottomGreen;
+int32 CTimeCycle::m_nCurrentFluffyCloudsBottomBlue;
+float CTimeCycle::m_fCurrentBlurRed;
+float CTimeCycle::m_fCurrentBlurGreen;
+float CTimeCycle::m_fCurrentBlurBlue;
+float CTimeCycle::m_fCurrentBlurAlpha;
+int32 CTimeCycle::m_nCurrentFogColourRed;
+int32 CTimeCycle::m_nCurrentFogColourGreen;
+int32 CTimeCycle::m_nCurrentFogColourBlue;
+
+int32 CTimeCycle::m_FogReduction;
+
+int32 CTimeCycle::m_CurrentStoredValue;
+CVector CTimeCycle::m_VectorToSun[16];
+float CTimeCycle::m_fShadowFrontX[16];
+float CTimeCycle::m_fShadowFrontY[16];
+float CTimeCycle::m_fShadowSideX[16];
+float CTimeCycle::m_fShadowSideY[16];
+float CTimeCycle::m_fShadowDisplacementX[16];
+float CTimeCycle::m_fShadowDisplacementY[16];
+
+
+void
+CTimeCycle::Initialise(void)
+{
+	int w, h;
+	int li, bi;
+	char line[1040];
+
+	int ambR, ambG, ambB;
+	int dirR, dirG, dirB;
+	int skyTopR, skyTopG, skyTopB;
+	int skyBotR, skyBotG, skyBotB;
+	int sunCoreR, sunCoreG, sunCoreB;
+	int sunCoronaR, sunCoronaG, sunCoronaB;
+	float sunSz, sprSz, sprBght;
+	int shad, lightShad, treeShad;
+	float farClp, fogSt, lightGnd;
+	int cloudR, cloudG, cloudB;
+	int fluffyTopR, fluffyTopG, fluffyTopB;
+	int fluffyBotR, fluffyBotG, fluffyBotB;
+	float blurR, blurG, blurB, blurA;
+
+	debug("Intialising CTimeCycle...\n");
+
+	CFileMgr::SetDir("DATA");
+	CFileMgr::LoadFile("TIMECYC.DAT", work_buff, sizeof(work_buff), "rb");
+	CFileMgr::SetDir("");
+
+	line[0] = '\0';
+	bi = 0;
+	for(w = 0; w < NUMWEATHERS; w++)
+		for(h = 0; h < NUMHOURS; h++){
+			li = 0;
+			while(work_buff[bi] == '/'){
+				while(work_buff[bi] != '\n')
+					bi++;
+				bi++;
+			}
+			while(work_buff[bi] != '\n')
+				line[li++] = work_buff[bi++];
+			line[li] = '\0';
+			bi++;
+
+			sscanf(line, "%d %d %d  %d %d %d  %d %d %d  %d %d %d "
+			             "%d %d %d  %d %d %d  %f %f %f %d %d %d %f %f %f "
+			             "%d %d %d  %d %d %d  %d %d %d  %f %f %f %f",
+				&ambR, &ambG, &ambB,
+				 &dirR, &dirG, &dirB,
+				 &skyTopR, &skyTopG, &skyTopB,
+				 &skyBotR, &skyBotG, &skyBotB,
+				&sunCoreR, &sunCoreG, &sunCoreB,
+				 &sunCoronaR, &sunCoronaG, &sunCoronaB,
+				 &sunSz, &sprSz, &sprBght,
+				 &shad, &lightShad, &treeShad,
+				 &farClp, &fogSt, &lightGnd,
+				&cloudR, &cloudG, &cloudB,
+				 &fluffyTopR, &fluffyTopG, &fluffyTopB,
+				 &fluffyBotR, &fluffyBotG, &fluffyBotB,
+				 &blurR, &blurG, &blurB, &blurA);
+
+			m_nAmbientRed[h][w] = ambR;
+			m_nAmbientGreen[h][w] = ambG;
+			m_nAmbientBlue[h][w] = ambB;
+			m_nDirectionalRed[h][w] = dirR;
+			m_nDirectionalGreen[h][w] = dirG;
+			m_nDirectionalBlue[h][w] = dirB;
+			m_nSkyTopRed[h][w] = skyTopR;
+			m_nSkyTopGreen[h][w] = skyTopG;
+			m_nSkyTopBlue[h][w] = skyTopB;
+			m_nSkyBottomRed[h][w] = skyBotR;
+			m_nSkyBottomGreen[h][w] = skyBotG;
+			m_nSkyBottomBlue[h][w] = skyBotB;
+			m_nSunCoreRed[h][w] = sunCoreR;
+			m_nSunCoreGreen[h][w] = sunCoreG;
+			m_nSunCoreBlue[h][w] = sunCoreB;
+			m_nSunCoronaRed[h][w] = sunCoronaR;
+			m_nSunCoronaGreen[h][w] = sunCoronaG;
+			m_nSunCoronaBlue[h][w] = sunCoronaB;
+			m_fSunSize[h][w] = sunSz;
+			m_fSpriteSize[h][w] = sprSz;
+			m_fSpriteBrightness[h][w] = sprBght;
+			m_nShadowStrength[h][w] = shad;
+			m_nLightShadowStrength[h][w] = lightShad;
+			m_nTreeShadowStrength[h][w] = treeShad;
+			m_fFarClip[h][w] = farClp;
+			m_fFogStart[h][w] = fogSt;
+			m_fLightsOnGroundBrightness[h][w] = lightGnd;
+			m_nLowCloudsRed[h][w] = cloudR;
+			m_nLowCloudsGreen[h][w] = cloudG;
+			m_nLowCloudsBlue[h][w] = cloudB;
+			m_nFluffyCloudsTopRed[h][w] = fluffyTopR;
+			m_nFluffyCloudsTopGreen[h][w] = fluffyTopG;
+			m_nFluffyCloudsTopBlue[h][w] = fluffyTopB;
+			m_nFluffyCloudsBottomRed[h][w] = fluffyBotR;
+			m_nFluffyCloudsBottomGreen[h][w] = fluffyBotG;
+			m_nFluffyCloudsBottomBlue[h][w] = fluffyBotB;
+			m_fBlurRed[h][w] = blurR;
+			m_fBlurGreen[h][w] = blurG;
+			m_fBlurBlue[h][w] = blurB;
+			m_fBlurAlpha[h][w] = blurA;
+		}
+
+	m_FogReduction = 0;
+
+	debug("CTimeCycle ready\n");
+}
+
+void
+CTimeCycle::Update(void)
+{
+	int h1 = CClock::GetHours();
+	int h2 = (h1+1)%24;
+	int w1 = CWeather::OldWeatherType;
+	int w2 = CWeather::NewWeatherType;
+	float timeInterp = CClock::GetMinutes()/60.0f;
+	// coefficients for a bilinear interpolation
+	float c0 = (1.0f-timeInterp) * (1.0f-CWeather::InterpolationValue);
+	float c1 = timeInterp * (1.0f-CWeather::InterpolationValue);
+	float c2 = (1.0f-timeInterp) * CWeather::InterpolationValue;
+	float c3 = timeInterp * CWeather::InterpolationValue;
+
+#define INTERP(v) v[h1][w1]*c0 + v[h2][w1]*c1 + v[h1][w2]*c2 + v[h2][w2]*c3
+
+	m_nCurrentSkyTopRed = INTERP(m_nSkyTopRed);
+	m_nCurrentSkyTopGreen = INTERP(m_nSkyTopGreen);
+	m_nCurrentSkyTopBlue = INTERP(m_nSkyTopBlue);
+
+	m_nCurrentSkyBottomRed = INTERP(m_nSkyBottomRed);
+	m_nCurrentSkyBottomGreen = INTERP(m_nSkyBottomGreen);
+	m_nCurrentSkyBottomBlue = INTERP(m_nSkyBottomBlue);
+
+	m_fCurrentAmbientRed = INTERP(m_nAmbientRed);
+	m_fCurrentAmbientGreen = INTERP(m_nAmbientGreen);
+	m_fCurrentAmbientBlue = INTERP(m_nAmbientBlue);
+	m_fCurrentAmbientRed /= 255.0f;
+	m_fCurrentAmbientGreen /= 255.0f;
+	m_fCurrentAmbientBlue /= 255.0f;
+
+	m_fCurrentDirectionalRed = INTERP(m_nDirectionalRed);
+	m_fCurrentDirectionalGreen = INTERP(m_nDirectionalGreen);
+	m_fCurrentDirectionalBlue = INTERP(m_nDirectionalBlue);
+	m_fCurrentDirectionalRed /= 255.0f;
+	m_fCurrentDirectionalGreen /= 255.0f;
+	m_fCurrentDirectionalBlue /= 255.0f;
+
+	m_nCurrentSunCoreRed = INTERP(m_nSunCoreRed);
+	m_nCurrentSunCoreGreen = INTERP(m_nSunCoreGreen);
+	m_nCurrentSunCoreBlue = INTERP(m_nSunCoreBlue);
+
+	m_nCurrentSunCoronaRed = INTERP(m_nSunCoronaRed);
+	m_nCurrentSunCoronaGreen = INTERP(m_nSunCoronaGreen);
+	m_nCurrentSunCoronaBlue = INTERP(m_nSunCoronaBlue);
+
+	m_fCurrentSunSize = INTERP(m_fSunSize);
+	m_fCurrentSpriteSize = INTERP(m_fSpriteSize);
+	m_fCurrentSpriteBrightness = INTERP(m_fSpriteBrightness);
+	m_nCurrentShadowStrength = INTERP(m_nShadowStrength);
+	m_nCurrentLightShadowStrength = INTERP(m_nLightShadowStrength);
+	m_nCurrentTreeShadowStrength = INTERP(m_nTreeShadowStrength);
+	m_fCurrentFarClip = INTERP(m_fFarClip);
+	m_fCurrentFogStart = INTERP(m_fFogStart);
+	m_fCurrentLightsOnGroundBrightness = INTERP(m_fLightsOnGroundBrightness);
+
+	m_nCurrentLowCloudsRed = INTERP(m_nLowCloudsRed);
+	m_nCurrentLowCloudsGreen = INTERP(m_nLowCloudsGreen);
+	m_nCurrentLowCloudsBlue = INTERP(m_nLowCloudsBlue);
+
+	m_nCurrentFluffyCloudsTopRed = INTERP(m_nFluffyCloudsTopRed);
+	m_nCurrentFluffyCloudsTopGreen = INTERP(m_nFluffyCloudsTopGreen);
+	m_nCurrentFluffyCloudsTopBlue = INTERP(m_nFluffyCloudsTopBlue);
+
+	m_nCurrentFluffyCloudsBottomRed = INTERP(m_nFluffyCloudsBottomRed);
+	m_nCurrentFluffyCloudsBottomGreen = INTERP(m_nFluffyCloudsBottomGreen);
+	m_nCurrentFluffyCloudsBottomBlue = INTERP(m_nFluffyCloudsBottomBlue);
+
+	m_fCurrentBlurRed = INTERP(m_fBlurRed);
+	m_fCurrentBlurGreen = INTERP(m_fBlurGreen);
+	m_fCurrentBlurBlue = INTERP(m_fBlurBlue);
+	m_fCurrentBlurAlpha = INTERP(m_fBlurAlpha);
+
+	if(TheCamera.m_BlurType == MOTION_BLUR_NONE || TheCamera.m_BlurType == MOTION_BLUR_LIGHT_SCENE)
+		TheCamera.SetMotionBlur(m_fCurrentBlurRed, m_fCurrentBlurGreen, m_fCurrentBlurBlue, m_fCurrentBlurAlpha, MOTION_BLUR_LIGHT_SCENE);
+
+	if(m_FogReduction != 0)
+		m_fCurrentFarClip = Max(m_fCurrentFarClip, m_FogReduction/64.0f * 650.0f);
+	m_nCurrentFogColourRed = (m_nCurrentSkyTopRed + 2*m_nCurrentSkyBottomRed) / 3;
+	m_nCurrentFogColourGreen = (m_nCurrentSkyTopGreen + 2*m_nCurrentSkyBottomGreen) / 3;
+	m_nCurrentFogColourBlue = (m_nCurrentSkyTopBlue + 2*m_nCurrentSkyBottomBlue) / 3;
+
+	m_CurrentStoredValue = (m_CurrentStoredValue+1)&0xF;
+
+	float sunAngle = 2*PI*(CClock::GetMinutes() + CClock::GetHours()*60)/(24*60);
+	CVector &sunPos = GetSunDirection();
+	sunPos.x = Sin(sunAngle);
+	sunPos.y = 1.0f;
+	sunPos.z = 0.2f - Cos(sunAngle);
+	sunPos.Normalise();
+
+	CShadows::CalcPedShadowValues(sunPos, 
+		&m_fShadowFrontX[m_CurrentStoredValue], &m_fShadowFrontY[m_CurrentStoredValue],
+		&m_fShadowSideX[m_CurrentStoredValue], &m_fShadowSideY[m_CurrentStoredValue],
+		&m_fShadowDisplacementX[m_CurrentStoredValue], &m_fShadowDisplacementY[m_CurrentStoredValue]);
+
+	if(TheCamera.GetForward().z < -0.9f ||
+	   !CWeather::bScriptsForceRain && (CCullZones::PlayerNoRain() || CCullZones::CamNoRain() || CCutsceneMgr::IsRunning()))
+		m_FogReduction = Min(m_FogReduction+1, 64);
+	else
+		m_FogReduction = Max(m_FogReduction-1, 0);
+}
diff --git a/src/renderer/Timecycle.h b/src/renderer/Timecycle.h
new file mode 100644
index 00000000..d5d7b67a
--- /dev/null
+++ b/src/renderer/Timecycle.h
@@ -0,0 +1,152 @@
+#pragma once
+
+class CTimeCycle
+{
+	static int32 m_nAmbientRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nAmbientGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nAmbientBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nDirectionalRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nDirectionalGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nDirectionalBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyTopRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyTopGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyTopBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyBottomRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyBottomGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSkyBottomBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoreRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoreGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoreBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoronaRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoronaGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nSunCoronaBlue[NUMHOURS][NUMWEATHERS];
+	static float m_fSunSize[NUMHOURS][NUMWEATHERS];
+	static float m_fSpriteSize[NUMHOURS][NUMWEATHERS];
+	static float m_fSpriteBrightness[NUMHOURS][NUMWEATHERS];
+	static int16 m_nShadowStrength[NUMHOURS][NUMWEATHERS];
+	static int16 m_nLightShadowStrength[NUMHOURS][NUMWEATHERS];
+	static int16 m_nTreeShadowStrength[NUMHOURS][NUMWEATHERS];
+	static float m_fFogStart[NUMHOURS][NUMWEATHERS];
+	static float m_fFarClip[NUMHOURS][NUMWEATHERS];
+	static float m_fLightsOnGroundBrightness[NUMHOURS][NUMWEATHERS];
+	static int32 m_nLowCloudsRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nLowCloudsGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nLowCloudsBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsTopRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsTopGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsTopBlue[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsBottomRed[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsBottomGreen[NUMHOURS][NUMWEATHERS];
+	static int32 m_nFluffyCloudsBottomBlue[NUMHOURS][NUMWEATHERS];
+	static float m_fBlurRed[NUMHOURS][NUMWEATHERS];
+	static float m_fBlurGreen[NUMHOURS][NUMWEATHERS];
+	static float m_fBlurBlue[NUMHOURS][NUMWEATHERS];
+	static float m_fBlurAlpha[NUMHOURS][NUMWEATHERS];
+
+	static float m_fCurrentAmbientRed;
+	static float m_fCurrentAmbientGreen;
+	static float m_fCurrentAmbientBlue;
+	static float m_fCurrentDirectionalRed;
+	static float m_fCurrentDirectionalGreen;
+	static float m_fCurrentDirectionalBlue;
+	static int32 m_nCurrentSkyTopRed;
+	static int32 m_nCurrentSkyTopGreen;
+	static int32 m_nCurrentSkyTopBlue;
+	static int32 m_nCurrentSkyBottomRed;
+	static int32 m_nCurrentSkyBottomGreen;
+	static int32 m_nCurrentSkyBottomBlue;
+	static int32 m_nCurrentSunCoreRed;
+	static int32 m_nCurrentSunCoreGreen;
+	static int32 m_nCurrentSunCoreBlue;
+	static int32 m_nCurrentSunCoronaRed;
+	static int32 m_nCurrentSunCoronaGreen;
+	static int32 m_nCurrentSunCoronaBlue;
+	static float m_fCurrentSunSize;
+	static float m_fCurrentSpriteSize;
+	static float m_fCurrentSpriteBrightness;
+	static int32 m_nCurrentShadowStrength;
+	static int32 m_nCurrentLightShadowStrength;
+	static int32 m_nCurrentTreeShadowStrength;
+	static float m_fCurrentFogStart;
+	static float m_fCurrentFarClip;
+	static float m_fCurrentLightsOnGroundBrightness;
+	static int32 m_nCurrentLowCloudsRed;
+	static int32 m_nCurrentLowCloudsGreen;
+	static int32 m_nCurrentLowCloudsBlue;
+	static int32 m_nCurrentFluffyCloudsTopRed;
+	static int32 m_nCurrentFluffyCloudsTopGreen;
+	static int32 m_nCurrentFluffyCloudsTopBlue;
+	static int32 m_nCurrentFluffyCloudsBottomRed;
+	static int32 m_nCurrentFluffyCloudsBottomGreen;
+	static int32 m_nCurrentFluffyCloudsBottomBlue;
+	static float m_fCurrentBlurRed;
+	static float m_fCurrentBlurGreen;
+	static float m_fCurrentBlurBlue;
+	static float m_fCurrentBlurAlpha;
+	static int32 m_nCurrentFogColourRed;
+	static int32 m_nCurrentFogColourGreen;
+	static int32 m_nCurrentFogColourBlue;
+
+	static int32 m_FogReduction;
+
+public:
+	static int32 m_CurrentStoredValue;
+	static CVector m_VectorToSun[16];
+	static float m_fShadowFrontX[16];
+	static float m_fShadowFrontY[16];
+	static float m_fShadowSideX[16];
+	static float m_fShadowSideY[16];
+	static float m_fShadowDisplacementX[16];
+	static float m_fShadowDisplacementY[16];
+
+	static float GetAmbientRed(void) { return m_fCurrentAmbientRed; }
+	static float GetAmbientGreen(void) { return m_fCurrentAmbientGreen; }
+	static float GetAmbientBlue(void) { return m_fCurrentAmbientBlue; }
+	static float GetDirectionalRed(void) { return m_fCurrentDirectionalRed; }
+	static float GetDirectionalGreen(void) { return m_fCurrentDirectionalGreen; }
+	static float GetDirectionalBlue(void) { return m_fCurrentDirectionalBlue; }
+	static int32 GetSkyTopRed(void) { return m_nCurrentSkyTopRed; }
+	static int32 GetSkyTopGreen(void) { return m_nCurrentSkyTopGreen; }
+	static int32 GetSkyTopBlue(void) { return m_nCurrentSkyTopBlue; }
+	static int32 GetSkyBottomRed(void) { return m_nCurrentSkyBottomRed; }
+	static int32 GetSkyBottomGreen(void) { return m_nCurrentSkyBottomGreen; }
+	static int32 GetSkyBottomBlue(void) { return m_nCurrentSkyBottomBlue; }
+	static int32 GetSunCoreRed(void) { return m_nCurrentSunCoreRed; }
+	static int32 GetSunCoreGreen(void) { return m_nCurrentSunCoreGreen; }
+	static int32 GetSunCoreBlue(void) { return m_nCurrentSunCoreBlue; }
+	static int32 GetSunCoronaRed(void) { return m_nCurrentSunCoronaRed; }
+	static int32 GetSunCoronaGreen(void) { return m_nCurrentSunCoronaGreen; }
+	static int32 GetSunCoronaBlue(void) { return m_nCurrentSunCoronaBlue; }
+	static float GetSunSize(void) { return m_fCurrentSunSize; }
+	static float GetSpriteBrightness(void) { return m_fCurrentSpriteBrightness; }
+	static float GetSpriteSize(void) { return m_fCurrentSpriteSize; }
+	static int32 GetShadowStrength(void) { return m_nCurrentShadowStrength; }
+	static int32 GetLightShadowStrength(void) { return m_nCurrentLightShadowStrength; }
+	static float GetLightOnGroundBrightness(void) { return m_fCurrentLightsOnGroundBrightness; }
+	static float GetFarClip(void) { return m_fCurrentFarClip; }
+	static float GetFogStart(void) { return m_fCurrentFogStart; }
+
+	static int32 GetLowCloudsRed(void) { return m_nCurrentLowCloudsRed; }
+	static int32 GetLowCloudsGreen(void) { return m_nCurrentLowCloudsGreen; }
+	static int32 GetLowCloudsBlue(void) { return m_nCurrentLowCloudsBlue; }
+	static int32 GetFluffyCloudsTopRed(void) { return m_nCurrentFluffyCloudsTopRed; }
+	static int32 GetFluffyCloudsTopGreen(void) { return m_nCurrentFluffyCloudsTopGreen; }
+	static int32 GetFluffyCloudsTopBlue(void) { return m_nCurrentFluffyCloudsTopBlue; }
+	static int32 GetFluffyCloudsBottomRed(void) { return m_nCurrentFluffyCloudsBottomRed; }
+	static int32 GetFluffyCloudsBottomGreen(void) { return m_nCurrentFluffyCloudsBottomGreen; }
+	static int32 GetFluffyCloudsBottomBlue(void) { return m_nCurrentFluffyCloudsBottomBlue; }
+	static int32 GetFogRed(void) { return m_nCurrentFogColourRed; }
+	static int32 GetFogGreen(void) { return m_nCurrentFogColourGreen; }
+	static int32 GetFogBlue(void) { return m_nCurrentFogColourBlue; }
+	static int32 GetFogReduction(void) { return m_FogReduction; }
+
+	static void Initialise(void);
+	static void Update(void);
+	static CVector &GetSunDirection(void) { return m_VectorToSun[m_CurrentStoredValue]; }
+	static float GetShadowFrontX(void) { return m_fShadowFrontX[m_CurrentStoredValue]; }
+	static float GetShadowFrontY(void) { return m_fShadowFrontY[m_CurrentStoredValue]; }
+	static float GetShadowSideX(void) { return m_fShadowSideX[m_CurrentStoredValue]; }
+	static float GetShadowSideY(void) { return m_fShadowSideY[m_CurrentStoredValue]; }
+	static float GetShadowDisplacementX(void) { return m_fShadowDisplacementX[m_CurrentStoredValue]; }
+	static float GetShadowDisplacementY(void) { return m_fShadowDisplacementY[m_CurrentStoredValue]; }
+};
diff --git a/src/renderer/WaterCannon.cpp b/src/renderer/WaterCannon.cpp
new file mode 100644
index 00000000..08898be8
--- /dev/null
+++ b/src/renderer/WaterCannon.cpp
@@ -0,0 +1,307 @@
+#include "common.h"
+
+#include "WaterCannon.h"
+#include "Vector.h"
+#include "General.h"
+#include "main.h"
+#include "Timer.h"
+#include "Pools.h"
+#include "Ped.h"
+#include "AnimManager.h"
+#include "Fire.h"
+#include "WaterLevel.h"
+#include "Camera.h"
+
+#define WATERCANNONVERTS 4
+#define WATERCANNONINDEXES 12
+
+RwIm3DVertex WaterCannonVertices[WATERCANNONVERTS];
+RwImVertexIndex WaterCannonIndexList[WATERCANNONINDEXES];
+
+CWaterCannon CWaterCannons::aCannons[NUM_WATERCANNONS];
+
+void CWaterCannon::Init(void)
+{
+	m_nId = 0;
+	m_nCur = 0;
+	m_nTimeCreated = CTimer::GetTimeInMilliseconds();
+	
+	for ( int32 i = 0; i < NUM_SEGMENTPOINTS; i++ )
+		m_abUsed[i] = false;
+	
+	RwIm3DVertexSetU(&WaterCannonVertices[0], 0.0f);
+	RwIm3DVertexSetV(&WaterCannonVertices[0], 0.0f);
+	
+	RwIm3DVertexSetU(&WaterCannonVertices[1], 1.0f);
+	RwIm3DVertexSetV(&WaterCannonVertices[1], 0.0f);
+	
+	RwIm3DVertexSetU(&WaterCannonVertices[2], 0.0f);
+	RwIm3DVertexSetV(&WaterCannonVertices[2], 0.0f);
+	
+	RwIm3DVertexSetU(&WaterCannonVertices[3], 1.0f);
+	RwIm3DVertexSetV(&WaterCannonVertices[3], 0.0f);
+	
+	WaterCannonIndexList[0]  = 0;
+	WaterCannonIndexList[1]  = 1;
+	WaterCannonIndexList[2]  = 2;
+	
+	WaterCannonIndexList[3]  = 1;
+	WaterCannonIndexList[4]  = 3;
+	WaterCannonIndexList[5]  = 2;
+	
+	WaterCannonIndexList[6]  = 0;
+	WaterCannonIndexList[7]  = 2;
+	WaterCannonIndexList[8]  = 1;
+	
+	WaterCannonIndexList[9]  = 1;
+	WaterCannonIndexList[10] = 2;
+	WaterCannonIndexList[11] = 3;
+}
+
+void CWaterCannon::Update_OncePerFrame(int16 index)
+{
+	ASSERT(index < NUM_WATERCANNONS);
+	
+	if (CTimer::GetTimeInMilliseconds() > m_nTimeCreated + WATERCANNON_LIFETIME )
+	{
+		m_nCur = (m_nCur + 1) % NUM_SEGMENTPOINTS;
+		m_abUsed[m_nCur] = false;
+	}
+	
+	for ( int32 i = 0; i < NUM_SEGMENTPOINTS; i++ )
+	{
+		if ( m_abUsed[i] )
+		{
+			m_avecVelocity[i].z += -WATERCANNON_GRAVITY * CTimer::GetTimeStep();
+			m_avecPos[i]        += m_avecVelocity[i]    * CTimer::GetTimeStep();
+		}
+	}
+	
+	int32 extinguishingPoint = CGeneral::GetRandomNumber() & (NUM_SEGMENTPOINTS - 1);
+	if ( m_abUsed[extinguishingPoint] )
+		gFireManager.ExtinguishPoint(m_avecPos[extinguishingPoint], 3.0f);
+	
+	if ( ((index + CTimer::GetFrameCounter()) & 3) == 0 )
+		PushPeds();
+	
+	// free if unused
+	
+	int32 i = 0;
+	while ( 1 )
+	{
+		if ( m_abUsed[i] )
+			break;
+		
+		if ( ++i >= NUM_SEGMENTPOINTS )
+		{
+			m_nId = 0;
+			return;
+		}
+	}
+}
+
+void CWaterCannon::Update_NewInput(CVector *pos, CVector *dir)
+{
+	ASSERT(pos != NULL);
+	ASSERT(dir != NULL);
+	
+	m_avecPos[m_nCur]      = *pos;
+	m_avecVelocity[m_nCur] = *dir;
+	m_abUsed[m_nCur]       = true;
+}
+
+void CWaterCannon::Render(void)
+{
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,         (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER,     (void *)gpWaterRaster);
+	
+	float v = float(CGeneral::GetRandomNumber() & 255) / 256;
+		
+	RwIm3DVertexSetV(&WaterCannonVertices[0], v);
+	RwIm3DVertexSetV(&WaterCannonVertices[1], v);
+	RwIm3DVertexSetV(&WaterCannonVertices[2], v);
+	RwIm3DVertexSetV(&WaterCannonVertices[3], v);
+	
+	int16 pointA = m_nCur % NUM_SEGMENTPOINTS;
+	
+	int16 pointB = pointA - 1;
+	if ( pointB < 0 )
+		pointB += NUM_SEGMENTPOINTS;
+
+	bool bInit = false;
+	CVector norm;
+	
+	for ( int32 i = 0; i < NUM_SEGMENTPOINTS - 1; i++ )
+	{
+		if ( m_abUsed[pointA] && m_abUsed[pointB] )
+		{
+			if ( !bInit )
+			{
+				CVector cp = CrossProduct(m_avecPos[pointB] - m_avecPos[pointA], TheCamera.GetForward());
+				norm = cp * (0.05f / cp.Magnitude());
+				bInit = true;
+			}
+			
+			float dist       = float(i*i*i) / 300.0f + 1.0f;
+			float brightness = float(i) / NUM_SEGMENTPOINTS;
+			
+			int32 color = (int32)((1.0f - brightness*brightness) * 255.0f);
+			CVector offset = dist * norm;
+			
+			RwIm3DVertexSetRGBA(&WaterCannonVertices[0], color, color, color, color);
+			RwIm3DVertexSetPos (&WaterCannonVertices[0], m_avecPos[pointA].x - offset.x, m_avecPos[pointA].y - offset.y, m_avecPos[pointA].z - offset.z);
+				
+			RwIm3DVertexSetRGBA(&WaterCannonVertices[1], color, color, color, color);
+			RwIm3DVertexSetPos (&WaterCannonVertices[1], m_avecPos[pointA].x + offset.x, m_avecPos[pointA].y + offset.y, m_avecPos[pointA].z + offset.z);
+			
+			RwIm3DVertexSetRGBA(&WaterCannonVertices[2], color, color, color, color);
+			RwIm3DVertexSetPos (&WaterCannonVertices[2], m_avecPos[pointB].x - offset.x, m_avecPos[pointB].y - offset.y, m_avecPos[pointB].z - offset.z);
+			
+			RwIm3DVertexSetRGBA(&WaterCannonVertices[3], color, color, color, color);
+			RwIm3DVertexSetPos (&WaterCannonVertices[3], m_avecPos[pointB].x + offset.x, m_avecPos[pointB].y + offset.y, m_avecPos[pointB].z + offset.z);
+			
+			LittleTest();
+
+			if ( RwIm3DTransform(WaterCannonVertices, WATERCANNONVERTS, NULL, rwIM3D_VERTEXUV) )
+			{
+				RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, WaterCannonIndexList, WATERCANNONINDEXES);
+				RwIm3DEnd();
+			}
+		}
+		
+		pointA = pointB--;
+		if ( pointB < 0 )
+			pointB += NUM_SEGMENTPOINTS;
+	}
+	
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE,      (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)FALSE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,         (void *)FALSE);
+}
+
+void CWaterCannon::PushPeds(void)
+{
+	float minx = 10000.0f;
+	float maxx = -10000.0f;
+	float miny = 10000.0f;
+	float maxy = -10000.0f;
+	float minz = 10000.0f;
+	float maxz = -10000.0f;
+  
+	for ( int32 i = 0; i < NUM_SEGMENTPOINTS; i++ )
+	{
+		if ( m_abUsed[i] )
+		{
+			minx = Min(minx, m_avecPos[i].x);
+			maxx = Max(maxx, m_avecPos[i].x);
+			
+			miny = Min(miny, m_avecPos[i].y);
+			maxy = Max(maxy, m_avecPos[i].y);
+			
+			minz = Min(minz, m_avecPos[i].z);
+			maxz = Max(maxz, m_avecPos[i].z);
+		}
+	}
+	
+	for ( int32 i = CPools::GetPedPool()->GetSize() - 1; i >= 0; i--)
+	{
+		CPed *ped = CPools::GetPedPool()->GetSlot(i);
+		if ( ped )
+		{
+			if (   ped->GetPosition().x > minx && ped->GetPosition().x < maxx
+				&& ped->GetPosition().y > miny && ped->GetPosition().y < maxy
+				&& ped->GetPosition().z > minz && ped->GetPosition().z < maxz )
+			{
+				for ( int32 j = 0; j < NUM_SEGMENTPOINTS; j++ )
+				{
+					if ( m_abUsed[j] )
+					{
+						CVector dist = m_avecPos[j] - ped->GetPosition();
+						
+						if ( dist.MagnitudeSqr() < 5.0f )
+						{
+							int32 localDir = ped->GetLocalDirection(CVector2D(1.0f, 0.0f));
+							
+							ped->bIsStanding = false;
+							
+							ped->ApplyMoveForce(0.0f, 0.0f, 2.0f * CTimer::GetTimeStep());
+							
+							ped->m_vecMoveSpeed.x = (0.6f * m_avecVelocity[j].x + ped->m_vecMoveSpeed.x) * 0.5f;
+							ped->m_vecMoveSpeed.y = (0.6f * m_avecVelocity[j].y + ped->m_vecMoveSpeed.y) * 0.5f;
+							
+							ped->SetFall(2000, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), 0);
+							
+							CFire *fire = ped->m_pFire;
+							if ( fire )
+								fire->Extinguish();
+							
+							j = NUM_SEGMENTPOINTS;
+						}
+					}
+				}
+			}
+		}
+	}	
+}
+
+void CWaterCannons::Init(void)
+{
+	for ( int32 i = 0; i < NUM_WATERCANNONS; i++ )
+		aCannons[i].Init();
+}
+
+void CWaterCannons::UpdateOne(uint32 id, CVector *pos, CVector *dir)
+{
+	ASSERT(pos != NULL);
+	ASSERT(dir != NULL);
+	
+	// find the one by id
+	{
+		int32 n = 0;
+		while ( n < NUM_WATERCANNONS && id != aCannons[n].m_nId )
+			n++;
+		
+		if ( n < NUM_WATERCANNONS )
+		{
+			aCannons[n].Update_NewInput(pos, dir);
+			return;
+		}
+	}
+	
+	// if no luck then find a free one
+	{
+		int32 n = 0;
+		while ( n < NUM_WATERCANNONS && 0 != aCannons[n].m_nId )
+			n++;
+		
+		if ( n < NUM_WATERCANNONS )
+		{
+			aCannons[n].Init();
+			aCannons[n].m_nId = id;
+			aCannons[n].Update_NewInput(pos, dir);
+			return;
+		}
+	}
+}
+
+void CWaterCannons::Update(void)
+{
+	for ( int32 i = 0; i < NUM_WATERCANNONS; i++ )
+	{
+		if ( aCannons[i].m_nId != 0 )
+			aCannons[i].Update_OncePerFrame(i);
+	}
+}
+
+void CWaterCannons::Render(void)
+{
+	PUSH_RENDERGROUP("CWaterCannons::Render");
+	for ( int32 i = 0; i < NUM_WATERCANNONS; i++ )
+	{
+		if ( aCannons[i].m_nId != 0 )
+			aCannons[i].Render();
+	}
+	POP_RENDERGROUP();
+}
diff --git a/src/renderer/WaterCannon.h b/src/renderer/WaterCannon.h
new file mode 100644
index 00000000..a37bdd12
--- /dev/null
+++ b/src/renderer/WaterCannon.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#define WATERCANNON_GRAVITY (0.009f)
+#define WATERCANNON_LIFETIME (150)
+
+class CWaterCannon
+{
+public:
+	enum
+	{
+		NUM_SEGMENTPOINTS = 16,
+	};
+	
+	int32 m_nId;
+	int16 m_nCur;
+	uint32 m_nTimeCreated;
+	CVector m_avecPos[NUM_SEGMENTPOINTS];
+	CVector m_avecVelocity[NUM_SEGMENTPOINTS];
+	bool m_abUsed[NUM_SEGMENTPOINTS];
+	
+	void Init(void);
+	void Update_OncePerFrame(int16 index);
+	void Update_NewInput(CVector *pos, CVector *dir);
+	void Render(void);
+	void PushPeds(void);
+};
+
+VALIDATE_SIZE(CWaterCannon, 412);
+
+class CWaterCannons
+{
+public:
+	static CWaterCannon aCannons[NUM_WATERCANNONS];
+	
+	static void Init(void);
+	static void UpdateOne(uint32 id, CVector *pos, CVector *dir);
+	static void Update();
+	static void Render(void);
+};
\ No newline at end of file
diff --git a/src/renderer/WaterLevel.cpp b/src/renderer/WaterLevel.cpp
new file mode 100644
index 00000000..7001c0cf
--- /dev/null
+++ b/src/renderer/WaterLevel.cpp
@@ -0,0 +1,1554 @@
+#include "common.h"
+#include "main.h"
+#include "FileMgr.h"
+#include "FileLoader.h"
+#include "TxdStore.h"
+#include "Timer.h"
+#include "Weather.h"
+#include "Camera.h"
+#include "Vehicle.h"
+#include "Boat.h"
+#include "World.h"
+#include "General.h"
+#include "Timecycle.h"
+#include "ZoneCull.h"
+#include "Clock.h"
+#include "Particle.h"
+#include "ParticleMgr.h"
+#include "RwHelper.h"
+#include "Streaming.h"
+#include "CdStream.h"
+#include "Pad.h"
+#include "RenderBuffer.h"
+#include <rpworld.h>
+#include "WaterLevel.h"
+#include "MemoryHeap.h"
+
+
+float TEXTURE_ADDU;
+float TEXTURE_ADDV;
+
+int32 CWaterLevel::ms_nNoOfWaterLevels;
+float CWaterLevel::ms_aWaterZs[48];
+CRect CWaterLevel::ms_aWaterRects[48];
+int8 CWaterLevel::aWaterBlockList[MAX_LARGE_SECTORS][MAX_LARGE_SECTORS];
+int8 CWaterLevel::aWaterFineBlockList[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
+bool CWaterLevel::WavesCalculatedThisFrame;
+RpAtomic *CWaterLevel::ms_pWavyAtomic;
+RpGeometry *CWaterLevel::apGeomArray[8];
+int16 CWaterLevel::nGeomUsed;
+//"Custom" Don't Render Water Toggle
+bool gbDontRenderWater;
+
+//RwTexture *gpWaterTex;
+//RwRaster *gpWaterRaster;
+
+RwTexture *gpWaterTex;
+RwRaster *gpWaterRaster;
+
+
+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;
+
+
+void
+CWaterLevel::Initialise(Const char *pWaterDat)
+{
+	ms_nNoOfWaterLevels = 0;
+
+#ifdef MASTER
+	int32 hFile = -1;
+
+	do
+	{
+		hFile = CFileMgr::OpenFile("DATA\\waterpro.dat", "rb");
+	}
+	while ( hFile < 0 );
+#else
+	int32 hFile = CFileMgr::OpenFile("DATA\\waterpro.dat", "rb");
+#endif
+
+	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::CloseFile(hFile);
+	}
+#ifndef MASTER
+	else
+	{
+		printf("Init waterlevels\n");
+
+		CFileMgr::SetDir("");
+		hFile = CFileMgr::OpenFile(pWaterDat, "r");
+
+		char *line;
+
+		while ((line = CFileLoader::LoadLine(hFile)))
+		{
+#ifdef FIX_BUGS
+			if (*line && *line != ';' && !strstr(line, "* ;end of file"))
+#else
+			if (*line && *line != ';')
+#endif
+			{
+				float z, l, b, r, t;
+				sscanf(line, "%f %f %f %f %f", &z, &l, &b, &r, &t);
+				AddWaterLevel(l, b, r, t, z);
+			}
+		}
+
+		CFileMgr::CloseFile(hFile);
+
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				aWaterFineBlockList[x][y] = NO_WATER;
+			}
+		}
+
+		// rasterize water rects read from file
+		for (int32 i = 0; i < ms_nNoOfWaterLevels; i++)
+		{
+			int32 l = WATER_HUGE_X(ms_aWaterRects[i].left);
+			int32 r = WATER_HUGE_X(ms_aWaterRects[i].right) + 1.0f;
+			int32 t = WATER_HUGE_Y(ms_aWaterRects[i].top);
+			int32 b = WATER_HUGE_Y(ms_aWaterRects[i].bottom) + 1.0f;
+
+#ifdef FIX_BUGS
+			// water.dat has rects that go out of bounds
+			// which causes memory corruption
+			l = Clamp(l, 0, MAX_SMALL_SECTORS - 1);
+			r = Clamp(r, 0, MAX_SMALL_SECTORS - 1);
+			t = Clamp(t, 0, MAX_SMALL_SECTORS - 1);
+			b = Clamp(b, 0, MAX_SMALL_SECTORS - 1);
+#endif
+
+			for (int32 x = l; x <= r; x++)
+			{
+				for (int32 y = t; y <= b; y++)
+				{
+					aWaterFineBlockList[x][y] = i;
+				}
+			}
+		}
+
+		// remove tiles that are obscured by land
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			float worldX = WATER_START_X + x * SMALL_SECTOR_SIZE;
+
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x][y] >= 0)
+				{
+					float worldY = WATER_START_Y + y * SMALL_SECTOR_SIZE;
+
+					int32 i;
+					for (i = 0; i <= 8; i++)
+					{
+						for (int32 j = 0; j <= 8; j++)
+						{
+							CVector worldPos = CVector(worldX + i * (SMALL_SECTOR_SIZE / 8), worldY + j * (SMALL_SECTOR_SIZE / 8), ms_aWaterZs[aWaterFineBlockList[x][y]]);
+
+							if ((worldPos.x > WORLD_MIN_X && worldPos.x < WORLD_MAX_X) && (worldPos.y > WORLD_MIN_Y && worldPos.y < WORLD_MAX_Y) &&
+							    (!WaterLevelAccordingToRectangles(worldPos.x, worldPos.y) || TestVisibilityForFineWaterBlocks(worldPos)))
+								continue;
+
+							// at least one point in the tile wasn't blocked, so don't remove water
+							i = 1000;
+							break;
+						}
+					}
+
+					if (i < 1000)
+						aWaterFineBlockList[x][y] = NO_WATER;
+				}
+			}
+		}
+
+		RemoveIsolatedWater();
+
+		// calculate coarse tiles from fine tiles
+		for (int32 x = 0; x < MAX_LARGE_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_LARGE_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x * 2][y * 2] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2];
+				}
+				else if (aWaterFineBlockList[x * 2 + 1][y * 2] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2];
+				}
+				else if (aWaterFineBlockList[x * 2][y * 2 + 1] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2 + 1];
+				}
+				else if (aWaterFineBlockList[x * 2 + 1][y * 2 + 1] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2 + 1];
+				}
+				else
+				{
+					aWaterBlockList[x][y] = NO_WATER;
+				}
+			}
+		}
+
+		hFile = CFileMgr::OpenFileForWriting("data\\waterpro.dat");
+
+		if (hFile > 0)
+		{
+			CFileMgr::Write(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
+			CFileMgr::Write(hFile, (char *)ms_aWaterZs,	sizeof(ms_aWaterZs));
+			CFileMgr::Write(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
+			CFileMgr::Write(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
+			CFileMgr::Write(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+
+			CFileMgr::CloseFile(hFile);
+		}
+	}
+#endif
+	
+	CTxdStore::PushCurrentTxd();
+
+	int32 slot = CTxdStore::FindTxdSlot("particle");
+	CTxdStore::SetCurrentTxd(slot);
+	
+	if ( gpWaterTex == nil )
+		gpWaterTex = RwTextureRead("water_old", nil);
+	gpWaterRaster = RwTextureGetRaster(gpWaterTex);
+	
+	CTxdStore::PopCurrentTxd();
+
+	CreateWavyAtomic();
+	FreeBoatWakeArray();
+	
+	printf("Done Initing waterlevels\n");
+}
+
+void
+CWaterLevel::Shutdown()
+{
+	FreeBoatWakeArray();
+	DestroyWavyAtomic();
+
+	if ( gpWaterTex != nil )
+	{
+		RwTextureDestroy(gpWaterTex);
+		gpWaterTex = nil;
+	}
+}
+
+void
+CWaterLevel::CreateWavyAtomic()
+{
+	RpGeometry *wavyGeometry;
+	RpMaterial *wavyMaterial;
+	RpTriangle *wavyTriangles;
+	RpMorphTarget *wavyMorphTarget;
+	RwSphere boundingSphere;	
+	RwV3d *wavyVert;
+
+	RwFrame *wavyFrame;
+	
+	{
+		wavyGeometry = RpGeometryCreate(9*9, 8*8*2, rpGEOMETRYTRISTRIP
+													|rpGEOMETRYTEXTURED
+													|rpGEOMETRYPRELIT
+													|rpGEOMETRYMODULATEMATERIALCOLOR);
+													
+		ASSERT(wavyGeometry != nil);
+	
+	}
+	
+	{
+		wavyMaterial = RpMaterialCreate();
+		
+		ASSERT(wavyMaterial != nil);
+		ASSERT(gpWaterTex   != nil);
+		
+		RpMaterialSetTexture(wavyMaterial, gpWaterTex);
+	}
+	
+	{
+		wavyTriangles = RpGeometryGetTriangles(wavyGeometry);
+		
+		ASSERT(wavyTriangles != nil);
+		/*  
+			[B]       [C]
+			 ***********
+			 *       * *
+			 *     *   *
+			 *   *     *
+			 * *       *
+			 ***********
+			[A]       [D]
+		*/
+		
+		for ( int32 i = 0; i < 8; i++ )
+		{
+			for ( int32 j = 0; j < 8; 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  );
+	
+				RpGeometryTriangleSetMaterial(wavyGeometry, &wavyTriangles[2 * 8*i + 2*j + 0], wavyMaterial);
+				RpGeometryTriangleSetMaterial(wavyGeometry, &wavyTriangles[2 * 8*i + 2*j + 1], wavyMaterial);
+			}
+		}
+	}
+	
+
+	{
+		wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
+		ASSERT(wavyMorphTarget != nil);
+		wavyVert = RpMorphTargetGetVertices(wavyMorphTarget);	
+		ASSERT(wavyVert != nil);
+		
+		for ( int32 i = 0; i < 9; i++ )
+		{
+			for ( int32 j = 0; j < 9; 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;
+			}
+		}
+		
+		RpMorphTargetCalcBoundingSphere(wavyMorphTarget, &boundingSphere);
+		RpMorphTargetSetBoundingSphere(wavyMorphTarget, &boundingSphere);
+		RpGeometryUnlock(wavyGeometry);
+	}
+	
+	
+	{
+		wavyFrame = RwFrameCreate();
+		ASSERT( wavyFrame != nil );
+		
+		ms_pWavyAtomic = RpAtomicCreate();		
+		ASSERT( ms_pWavyAtomic != nil );
+		
+		RpAtomicSetGeometry(ms_pWavyAtomic, wavyGeometry, 0);
+		RpAtomicSetFrame(ms_pWavyAtomic, wavyFrame);
+		RpMaterialDestroy(wavyMaterial);
+		RpGeometryDestroy(wavyGeometry);
+	}
+}
+
+void
+CWaterLevel::DestroyWavyAtomic()
+{
+	RwFrame *frame;
+	
+	frame = RpAtomicGetFrame(ms_pWavyAtomic);
+	
+	RpAtomicDestroy(ms_pWavyAtomic);
+	
+	RwFrameDestroy(frame);	
+}
+
+#ifndef MASTER
+void
+CWaterLevel::AddWaterLevel(float fXLeft, float fYBottom, float fXRight, float fYTop, float fLevel)
+{
+	ms_aWaterRects[ms_nNoOfWaterLevels] = CRect(fXLeft, fYBottom, fXRight, fYTop);
+	ms_aWaterZs[ms_nNoOfWaterLevels] = fLevel;
+	ms_nNoOfWaterLevels++;
+}
+
+bool
+CWaterLevel::WaterLevelAccordingToRectangles(float fX, float fY, float *pfOutLevel)
+{
+	if (ms_nNoOfWaterLevels <= 0) return false;
+
+	for (int32 i = 0; i < ms_nNoOfWaterLevels; i++)
+	{
+		if (fX >= ms_aWaterRects[i].left && fX <= ms_aWaterRects[i].right
+			&& fY >= ms_aWaterRects[i].top && fY <= ms_aWaterRects[i].bottom)
+		{
+			if (pfOutLevel) *pfOutLevel = ms_aWaterZs[i];
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool
+CWaterLevel::TestVisibilityForFineWaterBlocks(const CVector &worldPos)
+{
+	static CVector2D tab[] =
+	{
+		{ 50.0f, 50.0f },
+		{ -50.0f, 50.0f },
+		{ -50.0f, -50.0f },
+		{ 50.0f, -50.0f },
+		{ 50.0f, 0.0f },
+		{ -50.0f, 0.0f },
+		{ 0.0f, -50.0f },
+		{ 0.0f, 50.0f },
+	};
+
+	CEntity *entity;
+	CColPoint col;
+	CVector lineStart, lineEnd;
+
+	lineStart = worldPos;
+
+	if (!CWorld::ProcessVerticalLine(lineStart, lineStart.z + 100.0f, col, entity, true, false, false, false, true, false, nil))
+	{
+		lineStart.x += 0.4f;
+		lineStart.y += 0.4f;
+
+		if (!CWorld::ProcessVerticalLine(lineStart, lineStart.z + 100.0f, col, entity, true, false, false, false, true, false, nil))
+		{
+			return false;
+		}
+	}
+
+	for (int32 i = 0; i < ARRAY_SIZE(tab); i++)
+	{
+		lineStart = worldPos;
+		lineEnd = worldPos;
+
+		lineEnd.x += tab[i].x;
+		lineEnd.y += tab[i].y;
+		lineEnd.z += 100.0f;
+
+		if ((lineEnd.x > WORLD_MIN_X && lineEnd.x < WORLD_MAX_X) && (lineEnd.y > WORLD_MIN_Y && lineEnd.y < WORLD_MAX_Y))
+		{
+			if (!CWorld::ProcessLineOfSight(lineStart, lineEnd, col, entity, true, false, false, false, true, false))
+			{
+				lineStart.x += 0.4f;
+				lineStart.y += 0.4f;
+				lineEnd.x += 0.4f;
+				lineEnd.y += 0.4f;
+
+				if (!CWorld::ProcessLineOfSight(lineStart, lineEnd, col, entity, true, false, false, false, true, false))
+				{
+					return false;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+void
+CWaterLevel::RemoveIsolatedWater()
+{
+	bool (*isConnected)[MAX_SMALL_SECTORS] = new bool[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
+
+	for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+	{
+		for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+		{
+			isConnected[x][y] = false;
+		}
+	}
+
+	isConnected[0][0] = true;
+	bool keepGoing;
+
+	do
+	{
+		keepGoing = false;
+
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x][y] < 0 || isConnected[x][y])
+					continue;
+
+				if (x > 0 && isConnected[x - 1][y])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (y > 0 && isConnected[x][y - 1])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (x + 1 < MAX_SMALL_SECTORS && isConnected[x + 1][y])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (y + 1 < MAX_SMALL_SECTORS && isConnected[x][y + 1])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+			}
+		}
+	}
+	while (keepGoing);
+
+	int32 numRemoved = 0;
+
+	for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+	{
+		for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+		{
+			if (aWaterFineBlockList[x][y] >= 0 && !isConnected[x][y] && ms_aWaterZs[aWaterFineBlockList[x][y]] == 0.0f)
+			{
+				numRemoved++;
+				aWaterFineBlockList[x][y] = NO_WATER;
+			}
+		}
+	}
+
+	printf("Removed %d isolated patches of water\n", numRemoved);
+
+	delete[] isConnected;
+}
+#endif
+
+bool
+CWaterLevel::GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool bDontCheckZ)
+{
+	int32 x = WATER_HUGE_X(fX);
+	int32 y = WATER_HUGE_Y(fY);
+	
+	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
+	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
+
+	int8 nBlock = aWaterFineBlockList[x][y];
+
+	if ( nBlock == NO_WATER )
+		return false;
+
+	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) - float(x) * MAX_HUGE_SECTORS )*/ // VC
+		(float)( ((int32)fX & (MAX_HUGE_SECTORS-1)) + ((int32)fY & (MAX_HUGE_SECTORS-1)) )
+		* (TWOPI / MAX_HUGE_SECTORS ) + fAngle
+	);
+
+	float fWindFactor = CWeather::Wind * 0.7f + 0.3f;
+	
+	*pfOutLevel += fWave * fWindFactor;
+
+	if ( bDontCheckZ == false && (*pfOutLevel - fZ) > 3.0f )
+	{
+		*pfOutLevel = 0.0f;
+		return false;
+	}
+
+	return true;
+}
+
+bool
+CWaterLevel::GetWaterLevelNoWaves(float fX, float fY, float fZ, float *pfOutLevel)
+{
+	int32 x = WATER_HUGE_X(fX);
+	int32 y = WATER_HUGE_Y(fY);
+	
+	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
+	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
+	
+	int8 nBlock = aWaterFineBlockList[x][y];
+		
+	if ( nBlock == NO_WATER )
+		return false;
+	
+	ASSERT( pfOutLevel != nil );
+	*pfOutLevel = ms_aWaterZs[nBlock];
+
+	return true;
+}
+
+inline float
+_GetWaterDrawDist()
+{
+	// if z less then 15.0f return 1200.0f 
+	if ( TheCamera.GetPosition().z < 15.0f )
+		return 1200.0f;
+
+	// 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
+_GetWavyDrawDist()
+{
+	if ( FindPlayerVehicle() && FindPlayerVehicle()->IsBoat() )
+		return 120.0f;
+	else
+		return 70.0f;
+}
+
+inline void
+_GetCamBounds(bool *bUseCamStartY, bool *bUseCamEndY, bool *bUseCamStartX, bool *bUseCamEndX)
+{
+	if ( TheCamera.GetForward().z > -0.8f )
+	{
+		if ( Abs(TheCamera.GetForward().x) > Abs(TheCamera.GetForward().y) )
+		{
+			if ( TheCamera.GetForward().x > 0.0f )
+				*bUseCamStartX = true;
+			else
+				*bUseCamEndX = true;
+		}
+		else
+		{
+			if ( TheCamera.GetForward().y > 0.0f )
+				*bUseCamStartY = true;
+			else
+				*bUseCamEndY = true;
+		}
+	}
+}
+
+inline float
+SectorRadius(float fSize)
+{
+	return Sqrt(Pow(fSize, 2) + Pow(fSize, 2));
+}
+
+void
+CWaterLevel::RenderWater()
+{
+//"Custom" Don't Render Water Toggle
+#ifndef MASTER
+	if (gbDontRenderWater)
+		return;
+#endif
+	PUSH_RENDERGROUP("CWaterLevel::RenderWater");
+	bool bUseCamEndX   = false;
+	bool bUseCamStartY = false;
+	
+	bool bUseCamStartX = false;
+	bool bUseCamEndY   = false;
+	
+	float fWavySectorMaxRenderDist      = _GetWavyDrawDist();
+	float fWavySectorMaxRenderDistSqr   = SQR(fWavySectorMaxRenderDist);
+	
+	_GetCamBounds(&bUseCamStartY, &bUseCamEndY, &bUseCamStartX, &bUseCamEndX);
+
+	float fHugeSectorMaxRenderDist    = _GetWaterDrawDist();
+	float fHugeSectorMaxRenderDistSqr = SQR(fHugeSectorMaxRenderDist);
+	
+	float windAddUV = CWeather::Wind * 0.0015f + 0.0005f;
+	
+	
+	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
+	}
+	
+	if ( TEXTURE_ADDU >= 1.0f )
+		TEXTURE_ADDU = 0.0f;
+	if ( TEXTURE_ADDV >= 1.0f )
+		TEXTURE_ADDV = 0.0f;
+	
+	WavesCalculatedThisFrame = false;
+
+	RwRGBA color = { 0, 0, 0, 255 };
+	
+	color.red   = uint32((CTimeCycle::GetDirectionalRed()   * 0.5f + CTimeCycle::GetAmbientRed()  ) * 255.0f);
+	color.green = uint32((CTimeCycle::GetDirectionalGreen() * 0.5f + CTimeCycle::GetAmbientGreen()) * 255.0f);
+	color.blue  = uint32((CTimeCycle::GetDirectionalBlue()  * 0.5f + CTimeCycle::GetAmbientBlue() ) * 255.0f);
+
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+	
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void *)gpWaterRaster);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE,     (void *)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND,      (void *)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND,     (void *)rwBLENDZERO);
+	
+	CVector2D camPos
+	(
+		TheCamera.GetPosition().x,
+		TheCamera.GetPosition().y
+	);
+
+	int32 nStartX = WATER_TO_HUGE_SECTOR_X(camPos.x - fHugeSectorMaxRenderDist);
+	int32 nEndX   = WATER_TO_HUGE_SECTOR_X(camPos.x + fHugeSectorMaxRenderDist) + 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);
+	if ( bUseCamEndX )
+		nEndX   = WATER_TO_HUGE_SECTOR_X(camPos.x);
+	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++ )
+		{
+			if (   aWaterBlockList[2*x+0][2*y+0] >= 0
+				|| aWaterBlockList[2*x+1][2*y+0] >= 0
+				|| aWaterBlockList[2*x+0][2*y+1] >= 0
+				|| aWaterBlockList[2*x+1][2*y+1] >= 0 )
+			{
+				float fX = WATER_FROM_HUGE_SECTOR_X(x);
+				float fY = WATER_FROM_HUGE_SECTOR_Y(y);
+
+				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)) )
+					{
+						if ( fHugeSectorDistToCamSqr >= SQR(500.0f) /*fHugeSectorNearDist*/ )
+						{
+							float fZ;
+	
+							if ( aWaterBlockList[2*x+0][2*y+0] >= 0 )
+								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+0] ];
+	
+							if ( aWaterBlockList[2*x+1][2*y+0] >= 0 )
+								fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+0] ];
+	
+							if ( aWaterBlockList[2*x+0][2*y+1] >= 0 )
+								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+1] ];
+	
+							if ( aWaterBlockList[2*x+1][2*y+1] >= 0 )
+								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] >= 0 )
+									{
+										float fLargeX = WATER_FROM_LARGE_SECTOR_X(x2);
+										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,
+											{
+												// 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] >= 0 )
+													{
+														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] >= 0 )
+													{
+														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] >= 0 )
+													{
+														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] >= 0 )
+													{
+														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] >= 0 )
+								}	//	for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
+							}	//	for ( int32 x2 = 2*x; x2 <= 2*x+1; x2++ )
+							//
+							
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	/*
+	 -----------      ----------------------       ----------------------
+	|    [N]    |    |       [ EndY ]       |     |       [  top ]       |
+	|           |    |                      |     |                      |
+	|[W] [0] [E]|    |[StartX]  []  [ EndX ]|     |[ left ]  []  [ right]|
+	|           |    |                      |     |                      |
+	|    [S]    |    |       [StartY]       |     |       [bottom]       |
+	 -----------      ----------------------       ----------------------
+	
+	
+	[S] [StartY]  [bottom]
+	[N] [EndY]    [top]
+	[W] [StartX]  [left]
+	[E] [EndX]    [right]
+	
+	[S]    -> [N] && [W]  -> [E]
+	bottom -> top && left -> right
+	*/
+
+	if ( !bUseCamStartY )
+	{
+		for ( int32 x = 0; x < 26; x++ )
+		{
+			for ( int32 y = 0; y < 5; y++ )
+			{
+				float fX = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f;
+				float fY = WATER_SIGN_Y(float(y) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f;
+				
+				CVector2D vecExtraHugeSectorCentre
+				(
+					fX + 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)) )
+					{
+						RenderOneFlatExtraHugeWaterPoly(
+							vecExtraHugeSectorCentre.x - EXTRAHUGE_SECTOR_SIZE/2,
+							vecExtraHugeSectorCentre.y - EXTRAHUGE_SECTOR_SIZE/2,
+							0.0f,
+							color);
+					}
+				}
+			}
+		}
+	}
+	
+	for ( int32 y = 5; y < 21; y++ )
+	{
+		for ( int32 x = 0; x < 5; x++ )
+		{
+			float fX = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f;
+			float fX2 = WATER_SIGN_X(float(x) * EXTRAHUGE_SECTOR_SIZE) - 1280.0f;
+			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
+				);
+				
+				float fCamDistToSector = (vecExtraHugeSectorCentre - camPos).Magnitude();
+				
+				if ( fCamDistToSector < fHugeSectorMaxRenderDistSqr )
+				{
+					if ( TheCamera.IsSphereVisible(CVector(vecExtraHugeSectorCentre.x, vecExtraHugeSectorCentre.y, 0.0f), SectorRadius(EXTRAHUGE_SECTOR_SIZE)) )
+					{
+						RenderOneFlatExtraHugeWaterPoly(
+							vecExtraHugeSectorCentre.x - EXTRAHUGE_SECTOR_SIZE/2,
+							vecExtraHugeSectorCentre.y - EXTRAHUGE_SECTOR_SIZE/2,
+							0.0f,
+							color);
+					}
+				}
+			}
+			
+			if ( !bUseCamEndX )
+			{
+				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)) )
+					{
+						RenderOneFlatExtraHugeWaterPoly(
+							vecExtraHugeSectorCentre.x - EXTRAHUGE_SECTOR_SIZE/2,
+							vecExtraHugeSectorCentre.y - EXTRAHUGE_SECTOR_SIZE/2,
+							0.0f,
+							color);
+					}
+				}
+			}
+		}
+	}
+
+	RenderAndEmptyRenderBuffer();
+	
+	CVector cur_pos = TheCamera.GetPosition();
+	
+	if ( !CCullZones::CamNoRain()
+		&& !CCullZones::PlayerNoRain()
+		&& CWeather::NewWeatherType == WEATHER_SUNNY
+		&& CClock::GetHours() > 6 && CClock::GetHours() < 20
+		&& WavesCalculatedThisFrame)
+	{
+		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 )
+		{
+			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);
+				
+				int32 nRot = CGeneral::GetRandomNumber() % CParticle::SIN_COS_TABLE_SIZE-1;
+				
+				float fCos = CParticle::Cos(nRot);
+				float fSin = CParticle::Sin(nRot);
+
+				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);
+			}
+		}
+	}
+	
+	DefinedState();
+
+	POP_RENDERGROUP();
+}
+
+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);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, color.alpha);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + SMALL_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + SMALL_SECTOR_SIZE, fY + SMALL_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + SMALL_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	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);
+	
+	
+	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::RenderOneFlatLargeWaterPoly(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);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, color.alpha);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + LARGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + LARGE_SECTOR_SIZE, fY + LARGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + LARGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	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);
+
+
+	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::RenderOneFlatHugeWaterPoly(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);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, 255);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + HUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + HUGE_SECTOR_SIZE, fY + HUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + HUGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	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);
+
+
+	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::RenderOneFlatExtraHugeWaterPoly(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);
+	RwIm3DVertexSetU    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDU);
+	RwIm3DVertexSetV    (&TempBufferRenderVertices[vidx + 0], TEXTURE_ADDV);
+	RwIm3DVertexSetRGBA (&TempBufferRenderVertices[vidx + 0], color.red, color.green, color.blue, 255);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 1], fX, fY + EXTRAHUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 2], fX + EXTRAHUGE_SECTOR_SIZE, fY + EXTRAHUGE_SECTOR_SIZE, fZ - WATER_Z_OFFSET);
+	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);
+	
+	RwIm3DVertexSetPos  (&TempBufferRenderVertices[vidx + 3], fX + EXTRAHUGE_SECTOR_SIZE, fY, fZ - WATER_Z_OFFSET);
+	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);
+
+
+	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::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &color, bool bUnk)
+{
+	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);	
+	
+	if ( !WavesCalculatedThisFrame )
+	{
+		nGeomUsed = 0;
+		
+		WavesCalculatedThisFrame = true;
+		
+		CBoat::FillBoatList();
+		
+		ASSERT( ms_pWavyAtomic != nil );
+
+		RpGeometry *geometry = RpAtomicGetGeometry(ms_pWavyAtomic);
+		
+		ASSERT( geometry != nil );
+
+		RwRGBA      *wavyPreLights = RpGeometryGetPreLightColors(geometry);
+		RwTexCoords *wavyTexCoords = RpGeometryGetVertexTexCoords(geometry, rwTEXTURECOORDINATEINDEX0);
+		RwV3d       *wavyVertices  = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(geometry, 0));
+		
+		ASSERT( wavyPreLights != nil );
+		ASSERT( wavyTexCoords != nil );
+		ASSERT( wavyVertices  != nil );
+
+		RpGeometryLock(geometry, rpGEOMETRYLOCKVERTICES
+								| rpGEOMETRYLOCKPRELIGHT
+								| rpGEOMETRYLOCKTEXCOORDS);
+		
+		for ( int32 i = 0; i < 9; i++ )
+		{
+			for ( int32 j = 0; j < 9; j++ )
+			{
+				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);
+
+				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)) );
+			}
+		}
+		
+		RpGeometryUnlock(geometry);
+	}
+	
+	static CBoat *apBoatList[4] = { nil };
+	
+	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) )
+	{
+		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 != nil );
+		ASSERT( geom != nil );
+		
+		RpAtomic *atomic = RpAtomicCreate();
+		ASSERT( atomic != nil );
+		
+		RpAtomicSetGeometry(atomic, geom, 0);
+		
+		RwFrame *frame = RwFrameCreate();
+		ASSERT( frame != nil );
+		
+		RwMatrixCopy(RwFrameGetMatrix(frame), RwFrameGetMatrix(RpAtomicGetFrame(ms_pWavyAtomic)));
+		RpAtomicSetFrame(atomic, frame);
+		
+		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));
+		
+		ASSERT( geomTexCoords != nil );
+		ASSERT( wavyTexCoord  != nil );
+		ASSERT( geomPreLights != nil );
+		ASSERT( geomVertices  != nil );
+		ASSERT( wavyVertices  != nil );
+
+		RpGeometryLock(geom, rpGEOMETRYLOCKVERTICES | rpGEOMETRYLOCKPRELIGHT | rpGEOMETRYLOCKTEXCOORDS);
+		
+		for ( int32 i = 0; i < 9; i++ )
+		{
+			for ( int32 j = 0; j < 9; j++ )
+			{
+				geomTexCoords[9*i+j] = wavyTexCoord[9*i+j];
+
+				float fVertexX = (float)i * 4.0f + fX;
+				float fVertexY = (float)j * 4.0f + fY;
+
+				float fDistMult = 0.0f;
+		
+				for ( int32 k = 0; k < 4; k++ )
+				{
+					if ( apBoatList[k] != nil )
+						fDistMult += CBoat::IsVertexAffectedByWake(CVector(fVertexX, fVertexY, 0.0f), apBoatList[k]);
+				}
+				
+				if ( fDistMult > 0.0f )
+				{
+					RwRGBA wakeColor;
+					
+					RwRGBAAssign(&wakeColor, &color);
+
+					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);
+
+				}
+				else
+					RwRGBAAssign(&geomPreLights[9*i+j], &color);
+				
+				
+				geomVertices[9*i+j].z = wavyVertices[9*i+j].z;
+			}
+		}
+		
+		RpGeometryUnlock(geom);
+		
+		
+		RwV3d pos = {0.0f, 0.0f, 0.0f};
+
+		pos.x = fX;
+		pos.z = fZ;
+		pos.y = fY;
+
+		RwFrameTranslate(RpAtomicGetFrame(atomic), &pos, rwCOMBINEREPLACE);
+
+		RpAtomicRender(atomic);
+		
+		RpAtomicDestroy(atomic);
+		RwFrameDestroy(frame);
+	}
+	else
+	{
+		RwV3d pos = { 0.0f, 0.0f, 0.0f };
+
+		pos.x = fX;
+		pos.y = fY;
+		pos.z = fZ;
+		
+		ASSERT( ms_pWavyAtomic != nil );
+		
+		RwFrameTranslate(RpAtomicGetFrame(ms_pWavyAtomic), &pos, rwCOMBINEREPLACE);
+		
+		RpAtomicRender(ms_pWavyAtomic);
+	}
+}
+
+float
+CWaterLevel::CalcDistanceToWater(float fX, float fY)
+{
+	const float fSectorMaxRenderDist = 75.0f;
+	
+	int32 nStartX = WATER_TO_SMALL_SECTOR_X(fX - fSectorMaxRenderDist) - 1;
+	int32 nEndX   = WATER_TO_SMALL_SECTOR_X(fX + fSectorMaxRenderDist) + 1;
+	int32 nStartY = WATER_TO_SMALL_SECTOR_Y(fY - fSectorMaxRenderDist) - 1;
+	int32 nEndY   = WATER_TO_SMALL_SECTOR_Y(fY + fSectorMaxRenderDist) + 1;
+	
+	nStartX = Clamp(nStartX, 0, MAX_SMALL_SECTORS - 1);
+	nEndX   = Clamp(nEndX,   0, MAX_SMALL_SECTORS - 1);
+	nStartY = Clamp(nStartY, 0, MAX_SMALL_SECTORS - 1);
+	nEndY   = Clamp(nEndY,   0, MAX_SMALL_SECTORS - 1);
+	
+	float fDistSqr = 1.0e10f;
+	
+	for ( int32 x = nStartX; x <= nEndX; x++ )
+	{
+		for ( int32 y = nStartY; y <= nEndY; y++ )
+		{
+			if ( aWaterFineBlockList[x][y] >= 0 )
+			{				
+				float fSectorX = WATER_FROM_SMALL_SECTOR_X(x);
+				float fSectorY = WATER_FROM_SMALL_SECTOR_Y(y);
+				
+				CVector2D vecDist
+				(
+					fSectorX + SMALL_SECTOR_SIZE - fX,
+					fSectorY + SMALL_SECTOR_SIZE - fY
+				);
+				
+				fDistSqr = Min(vecDist.MagnitudeSqr(), fDistSqr);
+			}
+		}
+	}
+
+	return Clamp(Sqrt(fDistSqr) - 23.0f, 0.0f, fSectorMaxRenderDist);
+}
+
+void
+CWaterLevel::RenderAndEmptyRenderBuffer()
+{
+	if ( TempBufferVerticesStored )
+	{
+		LittleTest();
+
+		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV) )
+		{
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+			RwIm3DEnd();
+		}
+	}
+	
+	TempBufferIndicesStored = 0;
+	TempBufferVerticesStored = 0;
+}
+
+void
+CWaterLevel::AllocateBoatWakeArray()
+{
+	CStreaming::MakeSpaceFor(14 * CDSTREAM_SECTOR_SIZE); 
+
+	PUSH_MEMID(MEMID_STREAM);
+
+	ASSERT(ms_pWavyAtomic != nil );
+	
+	RpGeometry    *wavyGeometry    = RpAtomicGetGeometry(ms_pWavyAtomic);
+	ASSERT(wavyGeometry    != nil );
+	RpMorphTarget *wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
+	RpMaterial    *wavyMaterial    = RpGeometryGetMaterial(wavyGeometry, 0);
+
+	ASSERT(wavyMorphTarget != nil );
+	ASSERT(wavyMaterial    != nil );
+
+	for ( int32 geom = 0; geom < MAX_BOAT_WAKES; geom++ )
+	{
+		if ( apGeomArray[geom] == nil )
+		{
+			apGeomArray[geom] = RpGeometryCreate(9*9, 8*8*2, rpGEOMETRYTRISTRIP
+															| rpGEOMETRYPRELIT
+															| rpGEOMETRYMODULATEMATERIALCOLOR
+															| rpGEOMETRYTEXTURED);
+			ASSERT(apGeomArray[geom] != nil);
+
+			RpTriangle *geomTriangles = RpGeometryGetTriangles(apGeomArray[geom]);
+			
+			ASSERT( geomTriangles != nil );
+
+			for ( int32 i = 0; i < 8; i++ )
+			{
+				for ( int32 j = 0; j < 8; j++ )
+				{
+					
+					/*  
+						[B]       [C]
+						 ***********
+						 *       * *
+						 *     *   *
+						 *   *     *
+						 * *       *
+						 ***********
+						[A]       [D]
+					*/
+					
+					
+					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);
+				}
+			}
+
+			RpMorphTarget *geomMorphTarget = RpGeometryGetMorphTarget(apGeomArray[geom], 0);
+			RwV3d         *geomVertices    = RpMorphTargetGetVertices(geomMorphTarget);
+			
+			ASSERT( geomMorphTarget != nil );
+			ASSERT( geomVertices != nil );
+
+			for ( int32 i = 0; i < 9; 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;
+				}
+			}
+
+			RpMorphTargetSetBoundingSphere(geomMorphTarget, RpMorphTargetGetBoundingSphere(wavyMorphTarget));			
+			RpGeometryUnlock(apGeomArray[geom]);
+		}
+	}
+
+	POP_MEMID();
+}
+
+void
+CWaterLevel::FreeBoatWakeArray()
+{
+	for ( int32 i = 0; i < MAX_BOAT_WAKES; i++ )
+	{
+		if ( apGeomArray[i] != nil )
+		{
+			RpGeometryDestroy(apGeomArray[i]);
+			apGeomArray[i] = nil;
+		}
+	}
+	
+	nGeomUsed = 0;  
+}
diff --git a/src/renderer/WaterLevel.h b/src/renderer/WaterLevel.h
new file mode 100644
index 00000000..b797f251
--- /dev/null
+++ b/src/renderer/WaterLevel.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#define WATER_Z_OFFSET (1.5f)
+
+#define NO_WATER -128
+
+#define MAX_SMALL_SECTORS      128
+#define MAX_LARGE_SECTORS      64
+#define MAX_HUGE_SECTORS       32
+#define MAX_EXTRAHUGE_SECTORS  16
+
+#define SMALL_SECTOR_SIZE      32
+#define LARGE_SECTOR_SIZE      64
+#define HUGE_SECTOR_SIZE       128
+#define EXTRAHUGE_SECTOR_SIZE  256
+
+#define WATER_START_X -2048.0f
+#define WATER_END_X    2048.0f
+
+#define WATER_START_Y -2048.0f
+#define WATER_END_Y    2048.0f
+
+#define WATER_WIDTH		((WATER_END_X - WATER_START_X))
+#define WATER_HEIGHT	((WATER_END_Y - WATER_START_Y))
+
+#define WATER_UNSIGN_X(x)                   ( (x) + (WATER_WIDTH /2) )
+#define WATER_UNSIGN_Y(y)                   ( (y) + (WATER_HEIGHT/2) )
+#define WATER_SIGN_X(x)                     ( (x) - (WATER_WIDTH /2) )
+#define WATER_SIGN_Y(y)                     ( (y) - (WATER_HEIGHT/2) )
+
+// 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     )
+#define WATER_FROM_SMALL_SECTOR_X(x)        ( ((x) - (MAX_SMALL_SECTORS/2)    ) * SMALL_SECTOR_SIZE     )
+#define WATER_FROM_SMALL_SECTOR_Y(y)        ( ((y) - (MAX_SMALL_SECTORS/2)    ) * SMALL_SECTOR_SIZE     )
+#define WATER_TO_SMALL_SECTOR_X(x)          ( WATER_UNSIGN_X(x)					/ SMALL_SECTOR_SIZE     )
+#define WATER_TO_SMALL_SECTOR_Y(y)          ( WATER_UNSIGN_Y(y)					/ SMALL_SECTOR_SIZE     )
+			
+// 64			
+#define WATER_LARGE_X(x)                    ( WATER_UNSIGN_X(x)					/ MAX_LARGE_SECTORS     )
+#define WATER_LARGE_Y(y)                    ( WATER_UNSIGN_Y(y)					/ MAX_LARGE_SECTORS     )
+#define WATER_FROM_LARGE_SECTOR_X(x)        ( ((x) - (MAX_LARGE_SECTORS/2)    ) * LARGE_SECTOR_SIZE     )
+#define WATER_FROM_LARGE_SECTOR_Y(y)        ( ((y) - (MAX_LARGE_SECTORS/2)    ) * LARGE_SECTOR_SIZE     )
+#define WATER_TO_LARGE_SECTOR_X(x)          ( WATER_UNSIGN_X(x)					/ LARGE_SECTOR_SIZE     )
+#define WATER_TO_LARGE_SECTOR_Y(y)          ( WATER_UNSIGN_Y(y)					/ LARGE_SECTOR_SIZE     )
+				
+// 128				
+#define WATER_HUGE_X(x)                     ( WATER_UNSIGN_X(x)					/ MAX_HUGE_SECTORS      )
+#define WATER_HUGE_Y(y)                     ( WATER_UNSIGN_Y(y)					/ MAX_HUGE_SECTORS      )
+#define WATER_FROM_HUGE_SECTOR_X(x)         ( ((x) - (MAX_HUGE_SECTORS/2)     ) * HUGE_SECTOR_SIZE      )
+#define WATER_FROM_HUGE_SECTOR_Y(y)         ( ((y) - (MAX_HUGE_SECTORS/2)     ) * HUGE_SECTOR_SIZE      )
+#define WATER_TO_HUGE_SECTOR_X(x)           ( WATER_UNSIGN_X(x)					/ HUGE_SECTOR_SIZE      )
+#define WATER_TO_HUGE_SECTOR_Y(y)           ( WATER_UNSIGN_Y(y)					/ HUGE_SECTOR_SIZE      )
+
+// 256	
+#define WATER_EXTRAHUGE_X(x)                ( WATER_UNSIGN_X(x)					/ MAX_EXTRAHUGE_SECTORS )
+#define WATER_EXTRAHUGE_Y(y)                ( WATER_UNSIGN_Y(y)					/ MAX_EXTRAHUGE_SECTORS )
+#define WATER_FROM_EXTRAHUGE_SECTOR_X(x)    ( ((x) - (MAX_EXTRAHUGE_SECTORS/2)) * EXTRAHUGE_SECTOR_SIZE )
+#define WATER_FROM_EXTRAHUGE_SECTOR_Y(y)    ( ((y) - (MAX_EXTRAHUGE_SECTORS/2)) * EXTRAHUGE_SECTOR_SIZE )
+#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 )
+
+
+#define MAX_BOAT_WAKES 8
+
+extern RwRaster* gpWaterRaster;
+extern bool gbDontRenderWater;
+
+class CWaterLevel
+{
+	static int32       ms_nNoOfWaterLevels;
+	static float       ms_aWaterZs[48];
+	static CRect       ms_aWaterRects[48];
+	static int8        aWaterBlockList[MAX_LARGE_SECTORS][MAX_LARGE_SECTORS];
+	static int8        aWaterFineBlockList[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
+	static bool        WavesCalculatedThisFrame;
+	static RpAtomic   *ms_pWavyAtomic;
+	static RpGeometry *apGeomArray[MAX_BOAT_WAKES];
+	static int16       nGeomUsed;
+
+public:
+	static void    Initialise(Const char *pWaterDat); // out of class in III PC and later because of SecuROM
+	static void    Shutdown();
+	static void    CreateWavyAtomic();
+	static void    DestroyWavyAtomic();
+	static void    AddWaterLevel(float fXLeft, float fYBottom, float fXRight, float fYTop, float fLevel);
+	static bool    WaterLevelAccordingToRectangles(float fX, float fY, float *pfOutLevel = nil);
+	static bool    TestVisibilityForFineWaterBlocks(const CVector &worldPos);
+	static void    RemoveIsolatedWater();
+	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 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();
+};
diff --git a/src/renderer/Weather.cpp b/src/renderer/Weather.cpp
new file mode 100644
index 00000000..e57d57d6
--- /dev/null
+++ b/src/renderer/Weather.cpp
@@ -0,0 +1,552 @@
+#include "common.h"
+
+#include "Weather.h"
+
+#include "Camera.h"
+#include "Clock.h"
+#include "CutsceneMgr.h"
+#include "DMAudio.h"
+#include "General.h"
+#include "Pad.h"
+#include "Particle.h"
+#include "RenderBuffer.h"
+#include "Stats.h"
+#include "Shadows.h"
+#include "Timecycle.h"
+#include "Timer.h"
+#include "Vehicle.h"
+#include "World.h"
+#include "ZoneCull.h"
+
+int32 CWeather::SoundHandle = -1;
+
+int32 CWeather::WeatherTypeInList;
+int16 CWeather::OldWeatherType;
+int16 CWeather::NewWeatherType;
+int16 CWeather::ForcedWeatherType;
+
+bool CWeather::LightningFlash;
+bool CWeather::LightningBurst;
+uint32 CWeather::LightningStart;
+uint32 CWeather::LightningFlashLastChange;
+uint32 CWeather::WhenToPlayLightningSound;
+uint32 CWeather::LightningDuration;
+
+float CWeather::Foggyness;
+float CWeather::CloudCoverage;
+float CWeather::Wind;
+float CWeather::Rain;
+float CWeather::InterpolationValue;
+float CWeather::WetRoads;
+float CWeather::Rainbow;
+
+bool CWeather::bScriptsForceRain;
+bool CWeather::Stored_StateStored;
+
+float CWeather::Stored_InterpolationValue;
+int16 CWeather::Stored_OldWeatherType;
+int16 CWeather::Stored_NewWeatherType;
+float CWeather::Stored_Rain;
+
+tRainStreak Streaks[NUM_RAIN_STREAKS];
+
+const int16 WeatherTypesList[] = {
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_CLOUDY, WEATHER_CLOUDY, WEATHER_RAINY, WEATHER_RAINY,
+	WEATHER_CLOUDY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_CLOUDY, WEATHER_FOGGY, WEATHER_FOGGY, WEATHER_CLOUDY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_CLOUDY, WEATHER_CLOUDY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_CLOUDY, WEATHER_CLOUDY, WEATHER_RAINY, WEATHER_RAINY,
+	WEATHER_CLOUDY, WEATHER_RAINY, WEATHER_CLOUDY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_FOGGY, WEATHER_FOGGY, WEATHER_SUNNY,
+	WEATHER_SUNNY, WEATHER_SUNNY, WEATHER_RAINY, WEATHER_CLOUDY,
+};
+
+const float Windyness[] = {
+	0.0f, // WEATHER_SUNNY
+	0.7f, // WEATHER_CLOUDY
+	1.0f, // WEATHER_RAINY
+	0.5f  // WEATHER_FOGGY
+};
+
+#define MIN_TIME_BETWEEN_LIGHTNING_FLASH_CHANGES (50)
+
+#define RAIN_CHANGE_SPEED (0.003f)
+
+#define DROPLETS_LEFT_OFFSET (10.0f)
+#define DROPLETS_RIGHT_OFFSET (10.0f)
+#define DROPLETS_TOP_OFFSET (10.0f)
+#define DROPLETS_BOTTOM_OFFSET (10.0f)
+
+#define STREAK_U (10.0f)
+#define STREAK_V (18.0f)
+#define LARGE_STREAK_COEFFICIENT (1.23f)
+#define STREAK_MIN_DISTANCE (8.0f)
+#define STREAK_MAX_DISTANCE (16.0f)
+
+#define SPLASH_CHECK_RADIUS (7.0f)
+#define SPLASH_OFFSET_RADIUS (2.0f)
+
+#define STREAK_LIFETIME (4.0f)
+#define STREAK_INTEROLATION_TIME (0.3f)
+
+#define RAIN_COLOUR_R (200)
+#define RAIN_COLOUR_G (200)
+#define RAIN_COLOUR_B (256)
+#define RAIN_ALPHA (255)
+
+void CWeather::Init(void)
+{
+	NewWeatherType = WEATHER_SUNNY;
+	bScriptsForceRain = false;
+	OldWeatherType = WEATHER_CLOUDY;
+	Stored_StateStored = false;
+	InterpolationValue = 0.0f;
+	WhenToPlayLightningSound = 0;
+	WeatherTypeInList = 0;
+	ForcedWeatherType = WEATHER_RANDOM;
+	SoundHandle = DMAudio.CreateEntity(AUDIOTYPE_WEATHER, (void*)1);
+	if (SoundHandle >= 0)
+		DMAudio.SetEntityStatus(SoundHandle, TRUE);
+}
+
+void CWeather::Update(void)
+{
+	float fNewInterpolation = CClock::GetMinutes() * 1.0f / 60;
+	if (fNewInterpolation < InterpolationValue) {
+		// new hour
+		OldWeatherType = NewWeatherType;
+		if (ForcedWeatherType >= 0)
+			NewWeatherType = ForcedWeatherType;
+		else {
+			WeatherTypeInList = (WeatherTypeInList + 1) % ARRAY_SIZE(WeatherTypesList);
+			NewWeatherType = WeatherTypesList[WeatherTypeInList];
+#ifdef FIX_BUGS
+		}
+		if (NewWeatherType == WEATHER_RAINY)
+			CStats::mmRain += CGeneral::GetRandomNumber() & 7;
+#else
+			if (NewWeatherType == WEATHER_RAINY)
+				CStats::mmRain += CGeneral::GetRandomNumber() & 7;
+		}
+#endif
+	}
+	InterpolationValue = fNewInterpolation;
+	if (CPad::GetPad(1)->GetRightShockJustDown()) {
+		NewWeatherType = (NewWeatherType + 1) % WEATHER_TOTAL;
+		OldWeatherType = NewWeatherType;
+	}
+
+	// Lightning
+	if (NewWeatherType != WEATHER_RAINY || OldWeatherType != WEATHER_RAINY) {
+		LightningFlash = false;
+		LightningBurst = false;
+	}
+	else{
+		if (LightningBurst) {
+			if ((CGeneral::GetRandomNumber() & 255) >= 32) {
+				// 0.875 probability
+				if (CTimer::GetTimeInMilliseconds() - LightningFlashLastChange > MIN_TIME_BETWEEN_LIGHTNING_FLASH_CHANGES) {
+					bool bOldLightningFlash = LightningFlash;
+					LightningFlash = CGeneral::GetRandomTrueFalse();
+					if (LightningFlash != bOldLightningFlash)
+						LightningFlashLastChange = CTimer::GetTimeInMilliseconds();
+				}
+			}
+			else {
+				// 0.125 probability
+				LightningBurst = false;
+				LightningDuration = Min(CTimer::GetFrameCounter() - LightningStart, 20);
+				LightningFlash = false;
+				WhenToPlayLightningSound = CTimer::GetTimeInMilliseconds() + 150 * (20 - LightningDuration);
+			}
+		}
+		else {
+			if (CGeneral::GetRandomNumber() >= 200) {
+				// lower probability on PC due to randomness bug
+				LightningFlash = false;
+			}
+			else {
+				LightningBurst = true;
+				LightningStart = CTimer::GetFrameCounter();
+				LightningFlashLastChange = CTimer::GetTimeInMilliseconds();
+				LightningFlash = true;
+			}
+		}
+	}
+	if (WhenToPlayLightningSound && CTimer::GetTimeInMilliseconds() > WhenToPlayLightningSound) {
+		DMAudio.PlayOneShot(SoundHandle, SOUND_LIGHTNING, LightningDuration);
+		CPad::GetPad(0)->StartShake(40 * LightningDuration + 100, 2 * LightningDuration + 80);
+		WhenToPlayLightningSound = 0;
+	}
+
+	// Wet roads
+	if (OldWeatherType == WEATHER_RAINY) {
+		if (NewWeatherType == WEATHER_RAINY)
+			WetRoads = 1.0f;
+		else
+			WetRoads = 1.0f - InterpolationValue;
+	}
+	else {
+		if (NewWeatherType == WEATHER_RAINY)
+			WetRoads = InterpolationValue;
+		else
+			WetRoads = 0.0f;
+	}
+
+	// Rain
+#ifndef VC_RAIN_NERF
+	float fNewRain;
+	if (NewWeatherType == WEATHER_RAINY) {
+		// if raining for >1 hour, values: 0, 0.33, 0.66, 0.99, switching every ~16.5s
+		fNewRain = ((uint16)CTimer::GetTimeInMilliseconds() >> 14) * 0.33f;
+		if (OldWeatherType != WEATHER_RAINY) {
+			if (InterpolationValue < 0.4f)
+				// if rain has just started (<24 minutes), always 0.5
+				fNewRain = 0.5f;
+			else
+				// if rain is ongoing for >24 minutes, values: 0.25, 0.5, 0.75, 1.0, switching every ~16.5s
+				fNewRain = 0.25f + ((uint16)CTimer::GetTimeInMilliseconds() >> 14) * 0.25f;
+		}
+	}
+	else
+		fNewRain = 0.0f;
+	if (Rain != fNewRain) { // ok to use comparasion
+		if (Rain < fNewRain)
+			Rain = Min(fNewRain, Rain + RAIN_CHANGE_SPEED * CTimer::GetTimeStep());
+		else
+			Rain = Max(fNewRain, Rain - RAIN_CHANGE_SPEED * CTimer::GetTimeStep());
+	}
+#else
+	float fNewRain;
+	if (NewWeatherType == WEATHER_RAINY) {
+		// if raining for >1 hour, values: 0, 0.33, switching every ~16.5s
+		fNewRain = (((uint16)CTimer::GetTimeInMilliseconds() >> 14) & 1) * 0.33f;
+		if (OldWeatherType != WEATHER_RAINY) {
+			if (InterpolationValue < 0.4f)
+				// if rain has just started (<24 minutes), always 0.5
+				fNewRain = 0.5f;
+			else
+				// if rain is ongoing for >24 minutes, values: 0.25, 0.5, switching every ~16.5s
+				fNewRain = 0.25f + (((uint16)CTimer::GetTimeInMilliseconds() >> 14) & 1) * 0.25f;
+		}
+		fNewRain = Max(fNewRain, 0.5f);
+	}
+	else
+		fNewRain = 0.0f;
+	Rain = fNewRain;
+#endif
+
+	// Clouds
+	if (OldWeatherType != WEATHER_SUNNY)
+		CloudCoverage = 1.0f - InterpolationValue;
+	else
+		CloudCoverage = 0.0f;
+	if (NewWeatherType != WEATHER_SUNNY)
+		CloudCoverage += InterpolationValue;
+	
+	// Fog
+	if (OldWeatherType == WEATHER_FOGGY)
+		Foggyness = 1.0f - InterpolationValue;
+	else
+		Foggyness = 0.0f;
+	if (NewWeatherType == WEATHER_FOGGY)
+		Foggyness += InterpolationValue;
+	if (OldWeatherType == WEATHER_RAINY && NewWeatherType == WEATHER_SUNNY && InterpolationValue < 0.5f && CClock::GetHours() > 6 && CClock::GetHours() < 21)
+		Rainbow = 1.0f - 4.0f * Abs(InterpolationValue - 0.25f) / 4.0f;
+	else
+		Rainbow = 0.0f;
+	Wind = InterpolationValue * Windyness[NewWeatherType] + (1.0f - InterpolationValue) * Windyness[OldWeatherType];
+	AddRain();
+}
+
+void CWeather::ForceWeather(int16 weather)
+{
+	ForcedWeatherType = weather;
+}
+
+void CWeather::ForceWeatherNow(int16 weather)
+{
+	OldWeatherType = weather;
+	NewWeatherType = weather;
+	ForcedWeatherType = weather;
+}
+
+void CWeather::ReleaseWeather()
+{
+	ForcedWeatherType = -1;
+}
+
+void CWeather::AddRain()
+{
+	if (CCullZones::CamNoRain() || CCullZones::PlayerNoRain())
+		return;
+	if (TheCamera.GetLookingLRBFirstPerson()) {
+		CVehicle* pVehicle = FindPlayerVehicle();
+		if (pVehicle && pVehicle->CarHasRoof()) {
+			CParticle::RemovePSystem(PARTICLE_RAINDROP_2D);
+			return;
+		}
+	}
+	if (Rain <= 0.1f)
+		return;
+	static RwRGBA colour;
+	float screen_width = SCREEN_WIDTH;
+	float screen_height = SCREEN_HEIGHT;
+	int cur_frame = (int)(3 * Rain) & 3;
+	int num_drops = (int)(2 * Rain) + 2;
+	static int STATIC_RAIN_ANGLE = -45;
+	static int count = 1500;
+	static int add_angle = 1;
+	if (--count == 0) {
+		count = 1;
+		if (add_angle) {
+			STATIC_RAIN_ANGLE += 12;
+			if (STATIC_RAIN_ANGLE > 45) {
+				count = 1500;
+				add_angle = !add_angle;
+			}
+		}
+		else {
+			STATIC_RAIN_ANGLE -= 12;
+			if (STATIC_RAIN_ANGLE < -45) {
+				count = 1500;
+				add_angle = !add_angle;
+			}
+		}
+	}
+	float rain_angle = DEGTORAD(STATIC_RAIN_ANGLE + ((STATIC_RAIN_ANGLE < 0) ? 360 : 0));
+	float sin_angle = Sin(rain_angle);
+	float cos_angle = Cos(rain_angle);
+	float base_x = 0.0f * cos_angle - 1.0f * sin_angle;
+	float base_y = 1.0f * cos_angle + 0.0f * sin_angle;
+	CVector xpos(0.0f, 0.0f, 0.0f);
+	for (int i = 0; i < 2 * num_drops; i++) {
+		CVector dir;
+		dir.x = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_x) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.y = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_y) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.z = 0;
+		CParticle::AddParticle(PARTICLE_RAINDROP_2D, xpos, dir, nil, CGeneral::GetRandomNumberInRange(0.5f, 0.9f),
+			colour, 0, rain_angle + CGeneral::GetRandomNumberInRange(-10, 10), cur_frame);
+		xpos.x += screen_width / (2 * num_drops);
+		xpos.x += CGeneral::GetRandomNumberInRange(-25.0f, 25.0f);
+	}
+	CVector ypos(0.0f, 0.0f, 0.0f);
+	for (int i = 0; i < num_drops; i++) {
+		CVector dir;
+		dir.x = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_x) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.y = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_y) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.z = 0;
+		CParticle::AddParticle(PARTICLE_RAINDROP_2D, ypos, dir, nil, CGeneral::GetRandomNumberInRange(0.5f, 0.9f),
+			colour, 0, rain_angle + CGeneral::GetRandomNumberInRange(-10, 10), cur_frame);
+		ypos.y += screen_width / num_drops;
+		ypos.y += CGeneral::GetRandomNumberInRange(-25.0f, 25.0f);
+	}
+	CVector ypos2(0.0f, 0.0f, 0.0f);
+	for (int i = 0; i < num_drops; i++) {
+		CVector dir;
+		dir.x = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_x) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.y = (CGeneral::GetRandomNumberInRange(-0.5f, 0.5f) + base_y) * CGeneral::GetRandomNumberInRange(10.0f, 25.0f);
+		dir.z = 0;
+		CParticle::AddParticle(PARTICLE_RAINDROP_2D, ypos2, dir, nil, CGeneral::GetRandomNumberInRange(0.5f, 0.9f),
+			colour, 0, rain_angle + CGeneral::GetRandomNumberInRange(-10, 10), cur_frame);
+		ypos2.y += screen_width / num_drops;
+		ypos2.y += CGeneral::GetRandomNumberInRange(-25.0f, 25.0f);
+	}
+	for (int i = 0; i < num_drops; i++) {
+		CVector pos;
+		pos.x = CGeneral::GetRandomNumberInRange(DROPLETS_LEFT_OFFSET, screen_width - DROPLETS_RIGHT_OFFSET);
+		pos.y = CGeneral::GetRandomNumberInRange(DROPLETS_TOP_OFFSET, screen_height - DROPLETS_TOP_OFFSET);
+		pos.z = 0.0f;
+		CParticle::AddParticle(PARTICLE_RAINDROP_2D, pos, CVector(0.0f, 0.0f, 0.0f), nil, CGeneral::GetRandomNumberInRange(0.5f, 0.9f),
+			colour, CGeneral::GetRandomNumberInRange(-10, 10), 360 - rain_angle + CGeneral::GetRandomNumberInRange(-30, 30), cur_frame, 50);
+	}
+	int num_splash_attempts = (int)(3 * Rain) + 1;
+	int num_splashes = (int)(3 * Rain) + 4;
+	CVector splash_points[4];
+	splash_points[0] = CVector(-RwCameraGetViewWindow(TheCamera.m_pRwCamera)->x, RwCameraGetViewWindow(TheCamera.m_pRwCamera)->y, 1.0f) *
+		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
+	splash_points[1] = CVector(RwCameraGetViewWindow(TheCamera.m_pRwCamera)->x, RwCameraGetViewWindow(TheCamera.m_pRwCamera)->y, 1.0f) *
+		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
+	splash_points[2] = 4.0f * CVector(-RwCameraGetViewWindow(TheCamera.m_pRwCamera)->x, RwCameraGetViewWindow(TheCamera.m_pRwCamera)->y, 1.0f) *
+		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
+	splash_points[3] = 4.0f * CVector(RwCameraGetViewWindow(TheCamera.m_pRwCamera)->x, RwCameraGetViewWindow(TheCamera.m_pRwCamera)->y, 1.0f) *
+		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
+	RwV3dTransformPoints(splash_points, splash_points, 4, RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera)));
+	CVector fp = (splash_points[0] + splash_points[1] + splash_points[2] + splash_points[3]) / 4;
+	for (int i = 0; i < num_splash_attempts; i++) {
+		CColPoint point;
+		CEntity* entity;
+		CVector np = fp + CVector(CGeneral::GetRandomNumberInRange(-SPLASH_CHECK_RADIUS, SPLASH_CHECK_RADIUS), CGeneral::GetRandomNumberInRange(-SPLASH_CHECK_RADIUS, SPLASH_CHECK_RADIUS), 0.0f);
+		if (CWorld::ProcessVerticalLine(np + CVector(0.0f, 0.0f, 40.0f), -40.0f, point, entity, true, false, false, false, true, false, nil)) {
+			for (int j = 0; j < num_splashes; j++)
+				CParticle::AddParticle((CGeneral::GetRandomTrueFalse() ? PARTICLE_RAIN_SPLASH : PARTICLE_RAIN_SPLASHUP),
+					CVector(
+						np.x + CGeneral::GetRandomNumberInRange(-SPLASH_OFFSET_RADIUS, SPLASH_OFFSET_RADIUS),
+						np.y + CGeneral::GetRandomNumberInRange(-SPLASH_OFFSET_RADIUS, SPLASH_OFFSET_RADIUS),
+						point.point.z + 0.1f),
+					CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, colour);
+		}
+	}
+}
+
+void RenderOneRainStreak(CVector pos, CVector unused, int intensity, bool scale, float distance)
+{
+	static float RandomTex;
+	static float RandomTexX;
+	static float RandomTexY;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 0] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 1] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 2] = TempBufferVerticesStored + 1;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 3] = TempBufferVerticesStored + 0;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 4] = TempBufferVerticesStored + 3;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 5] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 6] = TempBufferVerticesStored + 1;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 7] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 8] = TempBufferVerticesStored + 4;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 9] = TempBufferVerticesStored + 2;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 10] = TempBufferVerticesStored + 3;
+	TempBufferRenderIndexList[TempBufferIndicesStored + 11] = TempBufferVerticesStored + 4;
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + 0], 0, 0, 0, 0);
+	RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + 0], pos.x + 11.0f * TheCamera.GetUp().x, pos.y + 11.0f * TheCamera.GetUp().y, pos.z + 11.0f * TheCamera.GetUp().z);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + 1], 0, 0, 0, 0);
+	RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + 1], pos.x - 9.0f * TheCamera.GetRight().x, pos.y - 9.0f * TheCamera.GetRight().y, pos.z - 9.0f * TheCamera.GetRight().z);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + 2], RAIN_COLOUR_R * intensity / 256, RAIN_COLOUR_G * intensity / 256, RAIN_COLOUR_B * intensity / 256, RAIN_ALPHA);
+	RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + 2], pos.x, pos.y, pos.z);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + 3], 0, 0, 0, 0);
+	RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + 3], pos.x + 9.0f * TheCamera.GetRight().x, pos.y + 9.0f * TheCamera.GetRight().y, pos.z + 9.0f * TheCamera.GetRight().z);
+	RwIm3DVertexSetRGBA(&TempBufferRenderVertices[TempBufferVerticesStored + 4], 0, 0, 0, 0); 
+	RwIm3DVertexSetPos(&TempBufferRenderVertices[TempBufferVerticesStored + 4], pos.x - 11.0f * TheCamera.GetUp().x, pos.y - 11.0f * TheCamera.GetUp().y, pos.z - 11.0f * TheCamera.GetUp().z);
+	float u = STREAK_U;
+	float v = STREAK_V;
+	if (scale) {
+		u *= LARGE_STREAK_COEFFICIENT;
+		v *= LARGE_STREAK_COEFFICIENT;
+	}
+	float distance_coefficient;
+	if (distance < STREAK_MIN_DISTANCE)
+		distance_coefficient = 1.0f;
+	else if (distance > STREAK_MAX_DISTANCE)
+		distance_coefficient = 0.5f;
+	else
+		distance_coefficient = 1.0f - 0.5f * (distance - STREAK_MIN_DISTANCE) / (STREAK_MAX_DISTANCE - STREAK_MIN_DISTANCE);
+	u *= distance_coefficient;
+	v *= distance_coefficient;
+	if (!CTimer::GetIsPaused()) {
+		RandomTex = ((CGeneral::GetRandomNumber() & 255) - 128) * 0.01f;
+		RandomTexX = (CGeneral::GetRandomNumber() & 127) * 0.01f;
+		RandomTexY = (CGeneral::GetRandomNumber() & 127) * 0.01f;
+	}
+	RwIm3DVertexSetU(&TempBufferRenderVertices[TempBufferVerticesStored + 0], 0.5f * u - RandomTex + RandomTexX);
+	RwIm3DVertexSetV(&TempBufferRenderVertices[TempBufferVerticesStored + 0], -v * 0.5f + RandomTexY);
+	RwIm3DVertexSetU(&TempBufferRenderVertices[TempBufferVerticesStored + 1], RandomTexX);
+	RwIm3DVertexSetV(&TempBufferRenderVertices[TempBufferVerticesStored + 1], RandomTexY);
+	RwIm3DVertexSetU(&TempBufferRenderVertices[TempBufferVerticesStored + 2], 0.5f * u + RandomTexX);
+	RwIm3DVertexSetV(&TempBufferRenderVertices[TempBufferVerticesStored + 2], RandomTexY);
+	RwIm3DVertexSetU(&TempBufferRenderVertices[TempBufferVerticesStored + 3], u + RandomTexX);
+	RwIm3DVertexSetV(&TempBufferRenderVertices[TempBufferVerticesStored + 3], RandomTexY);
+	RwIm3DVertexSetU(&TempBufferRenderVertices[TempBufferVerticesStored + 4], 0.5f * u + RandomTex + RandomTexX);
+	RwIm3DVertexSetV(&TempBufferRenderVertices[TempBufferVerticesStored + 5], 0.5f * v + RandomTexY);
+	TempBufferIndicesStored += 12;
+	TempBufferVerticesStored += 5;
+}
+
+void CWeather::RenderRainStreaks(void)
+{
+	if (CTimer::GetIsCodePaused())
+		return;
+	int base_intensity = (64.0f - CTimeCycle::GetFogReduction()) / 64.0f * int(255 * Rain);
+	if (base_intensity == 0)
+		return;
+	TempBufferIndicesStored = 0;
+	TempBufferVerticesStored = 0;
+	for (int i = 0; i < NUM_RAIN_STREAKS; i++) {
+		if (Streaks[i].timer) {
+			float secondsElapsed = (CTimer::GetTimeInMilliseconds() - Streaks[i].timer) / 1024.0f;
+			if (secondsElapsed > STREAK_LIFETIME)
+				Streaks[i].timer = 0;
+			else{
+				int intensity;
+				if (secondsElapsed < STREAK_INTEROLATION_TIME)
+					intensity = base_intensity * 0.5f * secondsElapsed / STREAK_INTEROLATION_TIME;
+				else if (secondsElapsed > (STREAK_LIFETIME - STREAK_INTEROLATION_TIME))
+					intensity = (STREAK_LIFETIME - secondsElapsed) * 0.5f * base_intensity / STREAK_INTEROLATION_TIME;
+				else
+					intensity = base_intensity * 0.5f;
+				CVector dir = Streaks[i].direction;
+				dir.Normalise();
+				CVector pos = Streaks[i].position + secondsElapsed * Streaks[i].direction;
+				RenderOneRainStreak(pos, dir, intensity, false, (pos - TheCamera.GetPosition()).Magnitude());
+#ifndef FIX_BUGS // remove useless code
+				if (secondsElapsed > 1.0f && secondsElapsed < STREAK_LIFETIME - 1.0f) {
+					CGeneral::GetRandomNumber(), CGeneral::GetRandomNumber();
+				}
+#endif
+			}
+		}
+		else if ((CGeneral::GetRandomNumber() & 0xF00) == 0){
+			// 1/16 probability
+			Streaks[i].direction = CVector(4.0f, 4.0f, -4.0f);
+			Streaks[i].position = 6.0f * TheCamera.GetForward() + TheCamera.GetPosition() + CVector(-1.8f * Streaks[i].direction.x, -1.8f * Streaks[i].direction.y, 8.0f);
+			if (!CCutsceneMgr::IsRunning()) {
+				Streaks[i].position.x += 2.0f * FindPlayerSpeed().x * 60.0f;
+				Streaks[i].position.y += 2.0f * FindPlayerSpeed().y * 60.0f;
+			}
+			else
+				Streaks[i].position += (TheCamera.GetPosition() - TheCamera.m_RealPreviousCameraPosition) * 20.0f;
+			Streaks[i].position.x += ((CGeneral::GetRandomNumber() & 255) - 128) * 0.08f;
+			Streaks[i].position.y += ((CGeneral::GetRandomNumber() & 255) - 128) * 0.08f;
+			Streaks[i].timer = CTimer::GetTimeInMilliseconds();
+		}
+	}
+	if (TempBufferIndicesStored){
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEFOGTYPE, (void*)rwFOGTYPELINEAR);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpRainDropTex[3]));
+		if (RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, 1))
+		{
+			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
+			RwIm3DEnd();
+		}
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	}
+	TempBufferVerticesStored = 0;
+	TempBufferIndicesStored = 0;
+}
+
+void CWeather::StoreWeatherState()
+{
+	Stored_StateStored = true;
+	Stored_InterpolationValue = InterpolationValue;
+	Stored_Rain = Rain;
+	Stored_NewWeatherType = NewWeatherType;
+	Stored_OldWeatherType = OldWeatherType;
+}
+
+void CWeather::RestoreWeatherState()
+{
+#ifdef FIX_BUGS // it's not used anyway though
+	Stored_StateStored = false;
+#endif
+	InterpolationValue = Stored_InterpolationValue;
+	Rain = Stored_Rain;
+	NewWeatherType = Stored_NewWeatherType;
+	OldWeatherType = Stored_OldWeatherType;
+}
diff --git a/src/renderer/Weather.h b/src/renderer/Weather.h
new file mode 100644
index 00000000..9c670317
--- /dev/null
+++ b/src/renderer/Weather.h
@@ -0,0 +1,71 @@
+enum {
+	WEATHER_SUNNY,
+	WEATHER_CLOUDY,
+	WEATHER_RAINY,
+	WEATHER_FOGGY
+};
+
+class CWeather
+{
+public:
+	enum {
+		WEATHER_RANDOM = -1,
+		WEATHER_SUNNY = 0,
+		WEATHER_CLOUDY = 1,
+		WEATHER_RAINY = 2,
+		WEATHER_FOGGY = 3,
+		WEATHER_TOTAL = 4
+	};
+	static int32 SoundHandle;
+
+	static int32 WeatherTypeInList;
+	static int16 OldWeatherType;
+	static int16 NewWeatherType;
+	static int16 ForcedWeatherType;
+
+	static bool LightningFlash;
+	static bool LightningBurst;
+	static uint32 LightningStart;
+	static uint32 LightningFlashLastChange;
+	static uint32 WhenToPlayLightningSound;
+	static uint32 LightningDuration;
+
+	static float Foggyness;
+	static float CloudCoverage;
+	static float Wind;
+	static float Rain;
+	static float InterpolationValue;
+	static float WetRoads;
+	static float Rainbow;
+
+	static bool bScriptsForceRain;
+	static bool Stored_StateStored;
+	static float Stored_InterpolationValue;
+	static int16 Stored_OldWeatherType;
+	static int16 Stored_NewWeatherType;
+	static float Stored_Rain;
+
+	static void RenderRainStreaks(void);
+	static void Update(void);
+	static void Init(void);
+	
+	static void ReleaseWeather();
+	static void ForceWeather(int16);
+	static void ForceWeatherNow(int16);
+	static void StoreWeatherState();
+	static void RestoreWeatherState();
+	static void AddRain();
+};
+
+enum {
+	NUM_RAIN_STREAKS = 35
+};
+
+struct tRainStreak
+{
+	CVector position;
+	CVector direction;
+	uint32 timer;
+};
+
+extern RwTexture* gpRainDropTex[4];
\ No newline at end of file