diff --git a/src/core/Game.cpp b/src/core/Game.cpp
index 08623c65..d5b376f6 100644
--- a/src/core/Game.cpp
+++ b/src/core/Game.cpp
@@ -87,6 +87,7 @@
 #include "Zones.h"
 #include "debugmenu.h"
 #include "frontendoption.h"
+#include "postfx.h"
 
 eLevelName CGame::currLevel;
 bool CGame::bDemoMode = true;
@@ -148,6 +149,9 @@ CGame::InitialiseOnceBeforeRW(void)
 	CFileMgr::Initialise();
 	CdStreamInit(MAX_CDCHANNELS);
 	ValidateVersion();
+#ifdef EXTENDED_COLOURFILTER
+	CPostFX::InitOnce();
+#endif
 	return true;
 }
 
diff --git a/src/core/config.h b/src/core/config.h
index 43fc54fa..bb6adce6 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -208,6 +208,7 @@ enum Config {
 //#define NO_ISLAND_LOADING  // disable loadscreen between islands via loading all island data at once, consumes more memory and CPU
 //#define USE_TEXTURE_POOL
 #define CUTSCENE_BORDERS_SWITCH
+//#define EXTENDED_COLOURFILTER		// more options for colour filter (replaces mblur)
 
 // Particle
 //#define PC_PARTICLE
diff --git a/src/core/re3.cpp b/src/core/re3.cpp
index f9be4b51..9edd9497 100644
--- a/src/core/re3.cpp
+++ b/src/core/re3.cpp
@@ -29,6 +29,8 @@
 #include "Text.h"
 #include "WaterLevel.h"
 #include "main.h"
+#include "MBlur.h"
+#include "postfx.h"
 
 #ifndef _WIN32
 #include "assert.h"
@@ -461,6 +463,13 @@ DebugMenuPopulate(void)
 		DebugMenuAddVarBool8("Render", "Frame limiter", &FrontEndMenuManager.m_PrefsFrameLimiter, nil);
 		DebugMenuAddVarBool8("Render", "VSynch", &FrontEndMenuManager.m_PrefsVsync, nil);
 		DebugMenuAddVar("Render", "Max FPS", &RsGlobal.maxFPS, nil, 1, 1, 1000, nil);
+#ifdef EXTENDED_COLOURFILTER
+		static const char *filternames[] = { "None", "Simple", "Normal", "Mobile" };
+		e = DebugMenuAddVar("Render", "Colourfilter", &CPostFX::EffectSwitch, nil, 1, CPostFX::POSTFX_OFF, CPostFX::POSTFX_MOBILE, filternames);
+		DebugMenuEntrySetWrap(e, true);
+		DebugMenuAddVar("Render", "Intensity", &CPostFX::Intensity, nil, 0.05f, 0, 10.0f);
+		DebugMenuAddVarBool8("Render", "Motion Blur", &CPostFX::MotionBlurOn, nil);
+#endif
 		DebugMenuAddVarBool8("Render", "Show Ped Paths", &gbShowPedPaths, nil);
 		DebugMenuAddVarBool8("Render", "Show Car Paths", &gbShowCarPaths, nil);
 		DebugMenuAddVarBool8("Render", "Show Car Path Links", &gbShowCarPathsLinks, nil);
diff --git a/src/extras/postfx.cpp b/src/extras/postfx.cpp
new file mode 100644
index 00000000..6355dfb1
--- /dev/null
+++ b/src/extras/postfx.cpp
@@ -0,0 +1,475 @@
+#define WITHWINDOWS
+#define WITH_D3D
+#include "common.h"
+
+#ifdef EXTENDED_COLOURFILTER
+
+#ifndef LIBRW
+#error "Need librw for EXTENDED_COLOURFILTER"
+#endif
+
+#include "RwHelper.h"
+#include "Camera.h"
+#include "MBlur.h"
+#include "postfx.h"
+
+RwRaster *CPostFX::pFrontBuffer;
+RwRaster *CPostFX::pBackBuffer;
+bool CPostFX::bJustInitialised;
+int CPostFX::EffectSwitch = POSTFX_NORMAL;
+bool CPostFX::MotionBlurOn = false;
+
+static RwIm2DVertex Vertex[4];
+static RwIm2DVertex Vertex2[4];
+static RwImVertexIndex Index[6] = { 0, 1, 2, 0, 2, 3 };
+
+#ifdef RW_D3D9
+void *colourfilterIII_PS;
+void *contrast_PS;
+#endif
+#ifdef RW_OPENGL
+int32 u_blurcolor;
+int32 u_contrastAdd;
+int32 u_contrastMult;
+rw::gl3::Shader *colourFilterIII;
+rw::gl3::Shader *contrast;
+#endif
+
+void
+CPostFX::InitOnce(void)
+{
+#ifdef RW_OPENGL
+	u_blurcolor = rw::gl3::registerUniform("u_blurcolor");
+	u_contrastAdd = rw::gl3::registerUniform("u_contrastAdd");
+	u_contrastMult = rw::gl3::registerUniform("u_contrastMult");
+#endif
+}
+
+void
+CPostFX::Open(RwCamera *cam)
+{
+	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));
+	pFrontBuffer = RwRasterCreate(width, height, depth, rwRASTERTYPECAMERATEXTURE);
+	pBackBuffer = RwRasterCreate(width, height, depth, rwRASTERTYPECAMERATEXTURE);
+	bJustInitialised = true;
+
+	float zero, xmax, ymax;
+
+	if(RwRasterGetDepth(RwCameraGetRaster(cam)) == 16){
+		zero = HALFPX;
+		xmax = width + HALFPX;
+		ymax = height + HALFPX;
+	}else{
+		zero = -HALFPX;
+		xmax = width - HALFPX;
+		ymax = height - 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);
+
+
+	RwIm2DVertexSetScreenX(&Vertex2[0], zero + 2.0f);
+	RwIm2DVertexSetScreenY(&Vertex2[0], zero + 2.0f);
+	RwIm2DVertexSetScreenZ(&Vertex2[0], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex2[0], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex2[0], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex2[0], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex2[0], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex2[0], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex2[1], 2.0f);
+	RwIm2DVertexSetScreenY(&Vertex2[1], ymax + 2.0f);
+	RwIm2DVertexSetScreenZ(&Vertex2[1], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex2[1], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex2[1], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex2[1], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex2[1], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex2[1], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex2[2], xmax + 2.0f);
+	RwIm2DVertexSetScreenY(&Vertex2[2], ymax + 2.0f);
+	RwIm2DVertexSetScreenZ(&Vertex2[2], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex2[2], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex2[2], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex2[2], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex2[2], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex2[2], 255, 255, 255, 255);
+
+	RwIm2DVertexSetScreenX(&Vertex2[3], xmax + 2.0f);
+	RwIm2DVertexSetScreenY(&Vertex2[3], zero + 2.0f);
+	RwIm2DVertexSetScreenZ(&Vertex2[3], RwIm2DGetNearScreenZ());
+	RwIm2DVertexSetCameraZ(&Vertex2[3], RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetRecipCameraZ(&Vertex2[3], 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetU(&Vertex2[3], 1.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetV(&Vertex2[3], 0.0f, 1.0f/RwCameraGetNearClipPlane(cam));
+	RwIm2DVertexSetIntRGBA(&Vertex2[3], 255, 255, 255, 255);
+
+
+#ifdef RW_D3D9
+#include "shaders/colourfilterIII_PS.inc"
+	colourfilterIII_PS = rw::d3d::createPixelShader(colourfilterIII_PS_cso);
+#include "shaders/contrastPS.inc"
+	contrast_PS = rw::d3d::createPixelShader(contrastPS_cso);
+#endif
+#ifdef RW_OPENGL
+	using namespace rw::gl3;
+	{
+#ifdef RW_GLES2
+#include "gl2_shaders/im2d_gl2.inc"
+#include "gl2_shaders/colourfilterIII_fs_gl2.inc"
+#else
+#include "shaders/im2d_gl3.inc"
+#include "shaders/colourfilterIII_fs_gl3.inc"
+#endif
+	const char *vs[] = { shaderDecl, header_vert_src, im2d_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, colourfilterIII_frag_src, nil };
+	colourFilterIII = Shader::create(vs, fs);
+	assert(colourFilterIII);
+	}
+
+	{
+#ifdef RW_GLES2
+#include "gl2_shaders/im2d_gl2.inc"
+#include "gl2_shaders/contrast_fs_gl2.inc"
+#else
+#include "shaders/im2d_gl3.inc"
+#include "shaders/contrast_fs_gl3.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, im2d_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, contrast_frag_src, nil };
+	contrast = Shader::create(vs, fs);
+	assert(contrast);
+#endif
+	}
+
+#endif
+}
+
+void
+CPostFX::Close(void)
+{
+	if(pFrontBuffer){
+		RwRasterDestroy(pFrontBuffer);
+		pFrontBuffer = nil;
+	}
+	if(pBackBuffer){
+		RwRasterDestroy(pBackBuffer);
+		pBackBuffer = nil;
+	}
+#ifdef RW_D3D9
+	if(colourfilterIII_PS){
+		rw::d3d::destroyPixelShader(colourfilterIII_PS);
+		colourfilterIII_PS = nil;
+	}
+	if(contrast_PS){
+		rw::d3d::destroyPixelShader(contrast_PS);
+		contrast_PS = nil;
+	}
+#endif
+#ifdef RW_OPENGL
+	if(colourFilterIII){
+		colourFilterIII->destroy();
+		colourFilterIII = nil;
+	}
+	if(contrast){
+		contrast->destroy();
+		contrast = nil;
+	}
+#endif
+}
+
+void
+CPostFX::RenderOverlayBlur(RwCamera *cam, int32 r, int32 g, int32 b, int32 a)
+{
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, pFrontBuffer);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+
+	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(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+}
+
+void
+CPostFX::RenderOverlaySimple(RwCamera *cam, int32 r, int32 g, int32 b, int32 a)
+{
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+
+	r *= 0.6f;
+	g *= 0.6f;
+	b *= 0.6f;
+	a *= 0.6f;
+
+	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(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+}
+
+void
+CPostFX::RenderOverlaySniper(RwCamera *cam, int32 r, int32 g, int32 b, int32 a)
+{
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, pFrontBuffer);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+
+	RwIm2DVertexSetIntRGBA(&Vertex[0], r, g, b, 80);
+	RwIm2DVertexSetIntRGBA(&Vertex[1], r, g, b, 80);
+	RwIm2DVertexSetIntRGBA(&Vertex[2], r, g, b, 80);
+	RwIm2DVertexSetIntRGBA(&Vertex[3], r, g, b, 80);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+}
+
+float CPostFX::Intensity = 1.0f;
+
+void
+CPostFX::RenderOverlayShader(RwCamera *cam, int32 r, int32 g, int32 b, int32 a)
+{
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, pBackBuffer);
+
+	if(EffectSwitch == POSTFX_MOBILE){
+		float mult[3], add[3];
+		mult[0] = (r-64)/384.0f + 1.14f;
+		mult[1] = (g-64)/384.0f + 1.14f;
+		mult[2] = (b-64)/384.0f + 1.14f;
+		add[0] = r/1536.f;
+		add[1] = g/1536.f;
+		add[2] = b/1536.f;
+#ifdef RW_D3D9
+		rw::d3d::d3ddevice->SetPixelShaderConstantF(10, mult, 1);
+		rw::d3d::d3ddevice->SetPixelShaderConstantF(11, add, 1);
+
+		rw::d3d::im2dOverridePS = contrast_PS;
+#endif
+#ifdef RW_OPENGL
+		rw::gl3::im2dOverrideShader = contrast;
+		contrast->use();
+		glUniform3fv(contrast->uniformLocations[u_contrastMult], 1, mult);
+		glUniform3fv(contrast->uniformLocations[u_contrastAdd], 1, add);
+#endif
+	}else{
+		float f = Intensity;
+		float blurcolors[4];
+		blurcolors[0] = r/255.0f;
+		blurcolors[1] = g/255.0f;
+		blurcolors[2] = b/255.0f;
+		blurcolors[3] = a*f/255.0f;
+#ifdef RW_D3D9
+		rw::d3d::d3ddevice->SetPixelShaderConstantF(10, blurcolors, 1);
+		rw::d3d::im2dOverridePS = colourfilterIII_PS;
+#endif
+#ifdef RW_OPENGL
+		rw::gl3::im2dOverrideShader = colourFilterIII;
+		colourFilterIII->use();
+		glUniform4fv(colourFilterIII->uniformLocations[u_blurcolor], 1, blurcolors);
+#endif
+	}
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+#ifdef RW_D3D9
+	rw::d3d::im2dOverridePS = nil;
+#endif
+#ifdef RW_OPENGL
+	rw::gl3::im2dOverrideShader = nil;
+#endif
+}
+
+void
+CPostFX::RenderMotionBlur(RwCamera *cam, uint32 blur)
+{
+	if(blur == 0)
+		return;
+
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, pFrontBuffer);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	RwIm2DVertexSetIntRGBA(&Vertex[0], 255, 255, 255, blur);
+	RwIm2DVertexSetIntRGBA(&Vertex[1], 255, 255, 255, blur);
+	RwIm2DVertexSetIntRGBA(&Vertex[2], 255, 255, 255, blur);
+	RwIm2DVertexSetIntRGBA(&Vertex[3], 255, 255, 255, blur);
+
+	RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, Vertex, 4, Index, 6);
+}
+
+bool
+CPostFX::NeedBackBuffer(void)
+{
+	// Current frame -- needed for non-blur effect
+	switch(EffectSwitch){
+	case POSTFX_OFF:
+		// no actual rendering here
+		return false;
+	case POSTFX_SIMPLE:
+		return false;
+	case POSTFX_NORMAL:
+		if(MotionBlurOn)
+			return false;
+		else
+			return true;
+	case POSTFX_MOBILE:
+		return true;
+	}
+	return false;
+}
+
+bool
+CPostFX::NeedFrontBuffer(int32 type)
+{
+	// Last frame -- needed for motion blur
+	if(MotionBlurOn)
+		return true;
+	if(type == MOTION_BLUR_SNIPER)
+		return true;
+
+	return false;
+}
+
+void
+CPostFX::Render(RwCamera *cam, uint32 red, uint32 green, uint32 blue, uint32 blur, int32 type, uint32 bluralpha)
+{
+	switch(type)
+	{
+	case MOTION_BLUR_SECURITY_CAM:
+		red = 0;
+		green = 255;
+		blue = 0;
+		blur = 128;
+		break;
+	case MOTION_BLUR_INTRO:
+		red = 100;
+		green = 220;
+		blue = 230;
+		blur = 158;
+		break;
+	case MOTION_BLUR_INTRO2:
+		red = 80;
+		green = 255;
+		blue = 230;
+		blur = 138;
+		break;
+	case MOTION_BLUR_INTRO3:
+		red = 255;
+		green = 60;
+		blue = 60;
+		blur = 200;
+		break;
+	case MOTION_BLUR_INTRO4:
+		red = 255;
+		green = 180;
+		blue = 180;
+		blur = 128;
+		break;
+	}
+
+	if(pFrontBuffer == nil)
+		Open(cam);
+	assert(pFrontBuffer);
+	assert(pBackBuffer);
+
+	if(NeedBackBuffer()){
+		RwRasterPushContext(pBackBuffer);
+		RwRasterRenderFast(RwCameraGetRaster(cam), 0, 0);
+		RwRasterPopContext();
+	}
+
+	DefinedState();
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void*)rwFILTERNEAREST);
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+
+	if(type == MOTION_BLUR_SNIPER){
+		if(!bJustInitialised)
+			RenderOverlaySniper(cam, red, green, blue, blur);
+	}else switch(EffectSwitch){
+	case POSTFX_OFF:
+		// no actual rendering here
+		break;
+	case POSTFX_SIMPLE:
+		RenderOverlaySimple(cam, red, green, blue, blur);
+		break;
+	case POSTFX_NORMAL:
+		if(MotionBlurOn){
+			if(!bJustInitialised)
+				RenderOverlayBlur(cam, red, green, blue, blur);
+		}else{
+			RenderOverlayShader(cam, red, green, blue, blur);
+		}
+		break;
+	case POSTFX_MOBILE:
+		RenderOverlayShader(cam, red, green, blue, blur);
+		break;
+	}
+
+	// TODO? maybe we want this even without motion blur on sometimes?
+	if(MotionBlurOn)
+		if(!bJustInitialised)
+			RenderMotionBlur(cam, bluralpha);
+
+	RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+
+	if(NeedFrontBuffer(type)){
+		RwRasterPushContext(pFrontBuffer);
+		RwRasterRenderFast(RwCameraGetRaster(cam), 0, 0);
+		RwRasterPopContext();
+		bJustInitialised = false;
+	}else
+		bJustInitialised = true;
+}
+
+#endif
diff --git a/src/extras/postfx.h b/src/extras/postfx.h
new file mode 100644
index 00000000..658c2d88
--- /dev/null
+++ b/src/extras/postfx.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#ifdef EXTENDED_COLOURFILTER
+
+class CPostFX
+{
+public:
+	enum {
+		POSTFX_OFF,
+		POSTFX_SIMPLE,
+		POSTFX_NORMAL,
+		POSTFX_MOBILE
+	};
+	static RwRaster *pFrontBuffer;
+	static RwRaster *pBackBuffer;
+	static bool bJustInitialised;
+	static int EffectSwitch;
+	static bool MotionBlurOn;	// or use CMblur for that?
+	static float Intensity;
+
+	static void InitOnce(void);
+	static void Open(RwCamera *cam);
+	static void Close(void);
+	static void RenderOverlayBlur(RwCamera *cam, int32 r, int32 g, int32 b, int32 a);
+	static void RenderOverlaySimple(RwCamera *cam, int32 r, int32 g, int32 b, int32 a);
+	static void RenderOverlaySniper(RwCamera *cam, int32 r, int32 g, int32 b, int32 a);
+	static void RenderOverlayShader(RwCamera *cam, int32 r, int32 g, int32 b, int32 a);
+	static void RenderMotionBlur(RwCamera *cam, uint32 blur);
+	static void Render(RwCamera *cam, uint32 red, uint32 green, uint32 blue, uint32 blur, int32 type, uint32 bluralpha);
+	static bool NeedBackBuffer(void);
+	static bool NeedFrontBuffer(int32 type);
+	static bool UseBlurColours(void) { return EffectSwitch != POSTFX_SIMPLE; }
+};
+
+#endif
diff --git a/src/extras/shaders/Makefile b/src/extras/shaders/Makefile
new file mode 100644
index 00000000..87be011e
--- /dev/null
+++ b/src/extras/shaders/Makefile
@@ -0,0 +1,16 @@
+all: im2d_gl3.inc colourfilterIII_fs_gl3.inc contrast_fs_gl3.inc
+
+im2d_gl3.inc: im2d.vert
+	(echo 'const char *im2d_vert_src =';\
+	 sed 's/..*/"&\\n"/' im2d.vert;\
+	 echo ';') >im2d_gl3.inc
+
+colourfilterIII_fs_gl3.inc: colourfilterIII.frag
+	(echo 'const char *colourfilterIII_frag_src =';\
+	 sed 's/..*/"&\\n"/' colourfilterIII.frag;\
+	 echo ';') >colourfilterIII_fs_gl3.inc
+
+contrast_fs_gl3.inc: contrast.frag
+	(echo 'const char *contrast_frag_src =';\
+	 sed 's/..*/"&\\n"/' contrast.frag;\
+	 echo ';') >contrast_fs_gl3.inc
diff --git a/src/extras/shaders/colourfilterIII.frag b/src/extras/shaders/colourfilterIII.frag
new file mode 100644
index 00000000..e19a8600
--- /dev/null
+++ b/src/extras/shaders/colourfilterIII.frag
@@ -0,0 +1,28 @@
+uniform sampler2D tex0;
+uniform vec4 u_blurcolor;
+
+in vec4 v_color;
+in vec2 v_tex0;
+in float v_fog;
+
+out vec4 color;
+
+void
+main(void)
+{
+	float a = u_blurcolor.a;
+
+	vec4 doublec = clamp(u_blurcolor*2, 0.0, 1.0);
+	vec4 dst = texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));
+	vec4 prev = dst;
+	for(int i = 0; i < 5; i++){
+//		vec4 doublec = clamp(u_blurcolor*2, 0.0, 1.0);
+		vec4 tmp = dst*(1.0-a) + prev*doublec*a;
+		tmp += prev*u_blurcolor;
+		tmp += prev*u_blurcolor;
+		prev = clamp(tmp, 0.0, 1.0);
+	}
+	color.rgb = prev.rgb;
+	color.a = 1.0f;
+}
+
diff --git a/src/extras/shaders/colourfilterIII_PS.cso b/src/extras/shaders/colourfilterIII_PS.cso
new file mode 100644
index 00000000..cc41bcec
Binary files /dev/null and b/src/extras/shaders/colourfilterIII_PS.cso differ
diff --git a/src/extras/shaders/colourfilterIII_PS.hlsl b/src/extras/shaders/colourfilterIII_PS.hlsl
new file mode 100644
index 00000000..27f099ef
--- /dev/null
+++ b/src/extras/shaders/colourfilterIII_PS.hlsl
@@ -0,0 +1,15 @@
+sampler2D tex : register(s0);
+float4 blurcol : register(c10);
+
+float4 main(in float2 texcoord : TEXCOORD0) : COLOR0
+{
+	float a = blurcol.a;
+	float4 dst = tex2D(tex, texcoord.xy);
+	float4 prev = dst;
+	for(int i = 0; i < 5; i++){
+		float4 tmp = dst*(1-a) + prev*blurcol*a;
+		prev = saturate(tmp);
+	}
+	prev.a = 1.0f;
+	return prev;
+}
diff --git a/src/extras/shaders/colourfilterIII_PS.inc b/src/extras/shaders/colourfilterIII_PS.inc
new file mode 100644
index 00000000..db49de6c
--- /dev/null
+++ b/src/extras/shaders/colourfilterIII_PS.inc
@@ -0,0 +1,40 @@
+static unsigned char colourfilterIII_PS_cso[] = {
+  0x00, 0x02, 0xff, 0xff, 0xfe, 0xff, 0x2b, 0x00, 0x43, 0x54, 0x41, 0x42,
+  0x1c, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xff,
+  0x02, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x70, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x00,
+  0x01, 0x00, 0x2a, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00,
+  0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6c, 0x75, 0x72,
+  0x63, 0x6f, 0x6c, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x04, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x00,
+  0x04, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x70, 0x73, 0x5f, 0x32, 0x5f, 0x30, 0x00, 0x4d,
+  0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29,
+  0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x39, 0x2e,
+  0x32, 0x39, 0x2e, 0x39, 0x35, 0x32, 0x2e, 0x33, 0x31, 0x31, 0x31, 0x00,
+  0x51, 0x00, 0x00, 0x05, 0x00, 0x00, 0x0f, 0xa0, 0x00, 0x00, 0x80, 0x3f,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x03, 0xb0,
+  0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x90, 0x00, 0x08, 0x0f, 0xa0,
+  0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0f, 0x80, 0x00, 0x00, 0xe4, 0xb0,
+  0x00, 0x08, 0xe4, 0xa0, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x07, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x12, 0x00, 0x00, 0x04,
+  0x02, 0x00, 0x17, 0x80, 0x0a, 0x00, 0xff, 0xa0, 0x01, 0x00, 0xe4, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x07, 0x80,
+  0x02, 0x00, 0xe4, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x12, 0x00, 0x00, 0x04,
+  0x02, 0x00, 0x17, 0x80, 0x0a, 0x00, 0xff, 0xa0, 0x01, 0x00, 0xe4, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x07, 0x80,
+  0x02, 0x00, 0xe4, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x12, 0x00, 0x00, 0x04,
+  0x02, 0x00, 0x17, 0x80, 0x0a, 0x00, 0xff, 0xa0, 0x01, 0x00, 0xe4, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x07, 0x80,
+  0x02, 0x00, 0xe4, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x12, 0x00, 0x00, 0x04,
+  0x02, 0x00, 0x17, 0x80, 0x0a, 0x00, 0xff, 0xa0, 0x01, 0x00, 0xe4, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x05, 0x00, 0x00, 0x03, 0x01, 0x00, 0x07, 0x80,
+  0x02, 0x00, 0xe4, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x12, 0x00, 0x00, 0x04,
+  0x02, 0x00, 0x17, 0x80, 0x0a, 0x00, 0xff, 0xa0, 0x01, 0x00, 0xe4, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0x01, 0x00, 0x00, 0x02, 0x02, 0x00, 0x08, 0x80,
+  0x00, 0x00, 0x00, 0xa0, 0x01, 0x00, 0x00, 0x02, 0x00, 0x08, 0x0f, 0x80,
+  0x02, 0x00, 0xe4, 0x80, 0xff, 0xff, 0x00, 0x00
+};
diff --git a/src/extras/shaders/colourfilterIII_fs_gl3.inc b/src/extras/shaders/colourfilterIII_fs_gl3.inc
new file mode 100644
index 00000000..f57b9cdd
--- /dev/null
+++ b/src/extras/shaders/colourfilterIII_fs_gl3.inc
@@ -0,0 +1,30 @@
+const char *colourfilterIII_frag_src =
+"uniform sampler2D tex0;\n"
+"uniform vec4 u_blurcolor;\n"
+
+"in vec4 v_color;\n"
+"in vec2 v_tex0;\n"
+"in float v_fog;\n"
+
+"out vec4 color;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	float a = u_blurcolor.a;\n"
+
+"	vec4 doublec = clamp(u_blurcolor*2, 0.0, 1.0);\n"
+"	vec4 dst = texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));\n"
+"	vec4 prev = dst;\n"
+"	for(int i = 0; i < 5; i++){\n"
+"//		vec4 doublec = clamp(u_blurcolor*2, 0.0, 1.0);\n"
+"		vec4 tmp = dst*(1.0-a) + prev*doublec*a;\n"
+"		tmp += prev*u_blurcolor;\n"
+"		tmp += prev*u_blurcolor;\n"
+"		prev = clamp(tmp, 0.0, 1.0);\n"
+"	}\n"
+"	color.rgb = prev.rgb;\n"
+"	color.a = 1.0f;\n"
+"}\n"
+
+;
diff --git a/src/extras/shaders/contrast.frag b/src/extras/shaders/contrast.frag
new file mode 100644
index 00000000..d6dec478
--- /dev/null
+++ b/src/extras/shaders/contrast.frag
@@ -0,0 +1,18 @@
+uniform sampler2D tex0;
+uniform vec3 u_contrastAdd;
+uniform vec3 u_contrastMult;
+
+in vec4 v_color;
+in vec2 v_tex0;
+in float v_fog;
+
+out vec4 color;
+
+void
+main(void)
+{
+	vec4 dst = texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));
+	color.rgb = dst.rgb*u_contrastMult + u_contrastAdd;
+	color.a = 1.0f;
+}
+
diff --git a/src/extras/shaders/contrastPS.cso b/src/extras/shaders/contrastPS.cso
new file mode 100644
index 00000000..a87c48d7
Binary files /dev/null and b/src/extras/shaders/contrastPS.cso differ
diff --git a/src/extras/shaders/contrastPS.hlsl b/src/extras/shaders/contrastPS.hlsl
new file mode 100644
index 00000000..a1de1d81
--- /dev/null
+++ b/src/extras/shaders/contrastPS.hlsl
@@ -0,0 +1,21 @@
+struct PS_INPUT
+{
+	float4 position		: POSITION;
+	float3 texcoord0	: TEXCOORD0;
+	float4 color		: COLOR0;
+};
+
+uniform float3 contrastMult : register(c10);
+uniform float3 contrastAdd : register(c11);
+
+sampler2D tex : register(s0);
+
+float4
+main(PS_INPUT In) : COLOR
+{
+	float4 dst = tex2D(tex, In.texcoord0.xy);
+
+	dst.rgb = dst.rgb*contrastMult + contrastAdd;
+	dst.a = 1.0;
+	return dst;
+}
diff --git a/src/extras/shaders/contrastPS.inc b/src/extras/shaders/contrastPS.inc
new file mode 100644
index 00000000..5386792f
--- /dev/null
+++ b/src/extras/shaders/contrastPS.inc
@@ -0,0 +1,31 @@
+static unsigned char contrastPS_cso[] = {
+  0x00, 0x02, 0xff, 0xff, 0xfe, 0xff, 0x35, 0x00, 0x43, 0x54, 0x41, 0x42,
+  0x1c, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xff,
+  0x03, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x98, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0b, 0x00,
+  0x01, 0x00, 0x2e, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x74, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x2a, 0x00,
+  0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x88, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, 0x74,
+  0x41, 0x64, 0x64, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x03, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x6f, 0x6e, 0x74,
+  0x72, 0x61, 0x73, 0x74, 0x4d, 0x75, 0x6c, 0x74, 0x00, 0x74, 0x65, 0x78,
+  0x00, 0xab, 0xab, 0xab, 0x04, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x73, 0x5f, 0x32,
+  0x5f, 0x30, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74,
+  0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68,
+  0x61, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+  0x72, 0x20, 0x39, 0x2e, 0x32, 0x39, 0x2e, 0x39, 0x35, 0x32, 0x2e, 0x33,
+  0x31, 0x31, 0x31, 0x00, 0x51, 0x00, 0x00, 0x05, 0x00, 0x00, 0x0f, 0xa0,
+  0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80,
+  0x00, 0x00, 0x03, 0xb0, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x90,
+  0x00, 0x08, 0x0f, 0xa0, 0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0f, 0x80,
+  0x00, 0x00, 0xe4, 0xb0, 0x00, 0x08, 0xe4, 0xa0, 0x01, 0x00, 0x00, 0x02,
+  0x01, 0x00, 0x07, 0x80, 0x0a, 0x00, 0xe4, 0xa0, 0x04, 0x00, 0x00, 0x04,
+  0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0xe4, 0x80, 0x01, 0x00, 0xe4, 0x80,
+  0x0b, 0x00, 0xe4, 0xa0, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x80,
+  0x00, 0x00, 0x00, 0xa0, 0x01, 0x00, 0x00, 0x02, 0x00, 0x08, 0x0f, 0x80,
+  0x00, 0x00, 0xe4, 0x80, 0xff, 0xff, 0x00, 0x00
+};
diff --git a/src/extras/shaders/contrast_fs_gl3.inc b/src/extras/shaders/contrast_fs_gl3.inc
new file mode 100644
index 00000000..58aaf079
--- /dev/null
+++ b/src/extras/shaders/contrast_fs_gl3.inc
@@ -0,0 +1,20 @@
+const char *contrast_frag_src =
+"uniform sampler2D tex0;\n"
+"uniform vec3 u_contrastAdd;\n"
+"uniform vec3 u_contrastMult;\n"
+
+"in vec4 v_color;\n"
+"in vec2 v_tex0;\n"
+"in float v_fog;\n"
+
+"out vec4 color;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 dst = texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));\n"
+"	color.rgb = dst.rgb*u_contrastMult + u_contrastAdd;\n"
+"	color.a = 1.0f;\n"
+"}\n"
+
+;
diff --git a/src/extras/shaders/im2d.vert b/src/extras/shaders/im2d.vert
new file mode 100644
index 00000000..241593b1
--- /dev/null
+++ b/src/extras/shaders/im2d.vert
@@ -0,0 +1,21 @@
+uniform vec4 u_xform;
+
+layout(location = 0) in vec4 in_pos;
+layout(location = 2) in vec4 in_color;
+layout(location = 3) in vec2 in_tex0;
+
+out vec4 v_color;
+out vec2 v_tex0;
+out float v_fog;
+
+void
+main(void)
+{
+	gl_Position = in_pos;
+	gl_Position.w = 1.0;
+	gl_Position.xy = gl_Position.xy * u_xform.xy + u_xform.zw;
+	v_fog = DoFog(gl_Position.z);
+	gl_Position.xyz *= gl_Position.w;
+	v_color = in_color;
+	v_tex0 = in_tex0;
+}
diff --git a/src/extras/shaders/im2d_gl3.inc b/src/extras/shaders/im2d_gl3.inc
new file mode 100644
index 00000000..68341b39
--- /dev/null
+++ b/src/extras/shaders/im2d_gl3.inc
@@ -0,0 +1,23 @@
+const char *im2d_vert_src =
+"uniform vec4 u_xform;\n"
+
+"layout(location = 0) in vec4 in_pos;\n"
+"layout(location = 2) in vec4 in_color;\n"
+"layout(location = 3) in vec2 in_tex0;\n"
+
+"out vec4 v_color;\n"
+"out vec2 v_tex0;\n"
+"out float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	gl_Position = in_pos;\n"
+"	gl_Position.w = 1.0;\n"
+"	gl_Position.xy = gl_Position.xy * u_xform.xy + u_xform.zw;\n"
+"	v_fog = DoFog(gl_Position.z);\n"
+"	gl_Position.xyz *= gl_Position.w;\n"
+"	v_color = in_color;\n"
+"	v_tex0 = in_tex0;\n"
+"}\n"
+;
diff --git a/src/extras/shaders/make.cmd b/src/extras/shaders/make.cmd
new file mode 100644
index 00000000..8404ac6c
--- /dev/null
+++ b/src/extras/shaders/make.cmd
@@ -0,0 +1,3 @@
+@echo off
+for %%f in (*PS.hlsl) do "%DXSDK_DIR%\Utilities\bin\x86\fxc.exe" /T ps_2_0 /nologo /E main /Fo %%~nf.cso %%f
+for %%f in (*VS.hlsl) do "%DXSDK_DIR%\Utilities\bin\x86\fxc.exe" /T vs_2_0 /nologo /E main /Fo %%~nf.cso %%f
diff --git a/src/extras/shaders/makeinc.sh b/src/extras/shaders/makeinc.sh
new file mode 100644
index 00000000..a649af33
--- /dev/null
+++ b/src/extras/shaders/makeinc.sh
@@ -0,0 +1,5 @@
+#!sh
+for i in *cso; do
+	(echo -n 'static '
+	xxd -i $i | grep -v '_len = ') > ${i%cso}inc
+done
diff --git a/src/render/Hud.cpp b/src/render/Hud.cpp
index 1e536382..08c0cb85 100644
--- a/src/render/Hud.cpp
+++ b/src/render/Hud.cpp
@@ -175,7 +175,8 @@ void CHud::Draw()
 					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));
+					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);
@@ -183,7 +184,8 @@ void CHud::Draw()
 					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));
+					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 {
@@ -194,7 +196,9 @@ void CHud::Draw()
 					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));
+					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 if (Mode == CCam::MODE_1STPERSON_RUNABOUT) {
 					rect.left = (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(32.0f * 0.7f);
@@ -202,7 +206,8 @@ void CHud::Draw()
 					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));
+					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 if (Mode == CCam::MODE_ROCKETLAUNCHER || Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT) {
 					RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
@@ -216,29 +221,33 @@ void CHud::Draw()
 				}
 				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));
+					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.right = (SCREEN_WIDTH / 2);
-					rect.top = (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(210.0f);
-					rect.left = SCREEN_SCALE_X(210.0f) + (SCREEN_WIDTH / 2);
-					rect.bottom = SCREEN_HEIGHT / 2;
-					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255));
+					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.bottom = (SCREEN_HEIGHT / 2);
-					rect.right = (SCREEN_WIDTH / 2);
-					rect.top = SCREEN_SCALE_Y(210.0f) + (SCREEN_HEIGHT / 2);
-					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255));
+					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.right = (SCREEN_WIDTH / 2);
-					rect.bottom = (SCREEN_HEIGHT / 2);
-					rect.left = SCREEN_SCALE_X(210.0f) + (SCREEN_WIDTH / 2);
-					rect.top = SCREEN_SCALE_Y(210.0f) + (SCREEN_HEIGHT / 2);
-					Sprites[HUD_SITESNIPER].Draw(CRect(rect), CRGBA(255, 255, 255, 255));
+					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.1f, 0.01f);
 				}
 			}
 			RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void *)rwFILTERLINEAR);
diff --git a/src/render/MBlur.cpp b/src/render/MBlur.cpp
index ec811e56..de15358e 100644
--- a/src/render/MBlur.cpp
+++ b/src/render/MBlur.cpp
@@ -10,6 +10,7 @@
 #include "RwHelper.h"
 #include "Camera.h"
 #include "MBlur.h"
+#include "postfx.h"
 
 // Originally taken from RW example 'mblur'
 
@@ -27,6 +28,10 @@ extern "C" D3DCAPS8 _RwD3D8DeviceCaps;
 RwBool
 CMBlur::MotionBlurOpen(RwCamera *cam)
 {
+#ifdef EXTENDED_COLOURFILTER
+	CPostFX::Open(cam);
+	return TRUE;
+#else
 #ifdef GTA_PS2
 	RwRect rect = {0, 0, 0, 0};
 	
@@ -127,18 +132,22 @@ CMBlur::MotionBlurOpen(RwCamera *cam)
 	
 	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;
 }
 
@@ -192,12 +201,14 @@ CMBlur::CreateImmediateModeData(RwCamera *cam, RwRect *rect)
 	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
 	RwRGBA color = { (RwUInt8)red, (RwUInt8)green, (RwUInt8)blue, (RwUInt8)blur };
 #ifdef GTA_PS2
 	if( pFrontBuffer )
@@ -217,6 +228,7 @@ CMBlur::MotionBlurRender(RwCamera *cam, uint32 red, uint32 green, uint32 blue, u
 		OverlayRender(cam, nil, color, type, bluralpha);
 	}
 #endif
+#endif
 }
 
 void
diff --git a/src/render/Sprite2d.cpp b/src/render/Sprite2d.cpp
index 453ed004..98bb6eb2 100644
--- a/src/render/Sprite2d.cpp
+++ b/src/render/Sprite2d.cpp
@@ -178,6 +178,7 @@ CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const C
 		z = 1.0f/RecipNearClip;
 	}
 	recipz = 1.0f/z;
+	float offset = 1.0f/1024.0f;
 
 	// This is what we draw:
 	// 0---1
@@ -189,8 +190,8 @@ CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const C
 	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);
+	RwIm2DVertexSetU(&maVertices[0], 0.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[0], 0.0f+offset, recipz);
 
 	RwIm2DVertexSetScreenX(&maVertices[1], r.right);
 	RwIm2DVertexSetScreenY(&maVertices[1], r.top);
@@ -198,8 +199,8 @@ CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const C
 	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);
+	RwIm2DVertexSetU(&maVertices[1], 1.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[1], 0.0f+offset, recipz);
 
 	RwIm2DVertexSetScreenX(&maVertices[2], r.right);
 	RwIm2DVertexSetScreenY(&maVertices[2], r.bottom);
@@ -207,8 +208,8 @@ CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const C
 	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);
+	RwIm2DVertexSetU(&maVertices[2], 1.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[2], 1.0f+offset, recipz);
 
 	RwIm2DVertexSetScreenX(&maVertices[3], r.left);
 	RwIm2DVertexSetScreenY(&maVertices[3], r.bottom);
@@ -216,8 +217,8 @@ CSprite2d::SetVertices(const CRect &r, const CRGBA &c0, const CRGBA &c1, const C
 	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);
+	RwIm2DVertexSetU(&maVertices[3], 0.0f+offset, recipz);
+	RwIm2DVertexSetV(&maVertices[3], 1.0f+offset, recipz);
 }
 
 void