Merge branch 'master' into zcomploc-support

Conflicts:
	Source/Core/VideoCommon/Src/PixelShaderGen.cpp

16 files changed, 175 insertions, 256 deletions

diff --git a/Source/Plugins/Plugin_VideoDX9/Plugin_VideoDX9.vcxproj b/Source/Plugins/Plugin_VideoDX9/Plugin_VideoDX9.vcxproj
index 838004a605..604fea8a2b 100644
--- a/Source/Plugins/Plugin_VideoDX9/Plugin_VideoDX9.vcxproj
+++ b/Source/Plugins/Plugin_VideoDX9/Plugin_VideoDX9.vcxproj
@@ -46,7 +46,7 @@
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
@@ -57,7 +57,6 @@
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp b/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp
index de610eab39..ff3f68a6cd 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp
@@ -28,7 +28,8 @@ D3DXCOMPILESHADERTYPE PD3DXCompileShader = NULL;
 
 namespace DX9
 {
-
+static char vsVersions[5][7] = {"ERROR", "vs_1_4", "vs_2_a", "vs_3_0", "vs_4_0"};
+static char psVersions[5][7] = {"ERROR", "ps_1_4", "ps_2_a", "ps_3_0", "ps_4_0"};
 // D3DX
 HINSTANCE hD3DXDll = NULL;
 int d3dx_dll_ref = 0;
@@ -55,6 +56,7 @@ static bool auto_depth_stencil = false;
 
 #define VENDOR_NVIDIA 4318
 #define VENDOR_ATI    4098
+#define VENDOR_INTEL  32902
 
 bool bFrameInProgress = false;
 
@@ -112,6 +114,10 @@ bool IsATIDevice()
 {
 	return GetCurAdapter().ident.VendorId == VENDOR_ATI;
 }
+bool IsIntelDevice()
+{
+	return GetCurAdapter().ident.VendorId == VENDOR_INTEL;
+}
 
 
 HRESULT Init()
@@ -139,6 +145,11 @@ HRESULT Init()
 	int adapter = g_Config.iAdapter;
 	D3D->GetDeviceCaps((adapter >= 0 && adapter < std::min(MAX_ADAPTERS, numAdapters)) ? adapter : D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
 	Enumerate();
+	if(IsIntelDevice()){
+		// Murder the a because Intel doesn't support 2.0a because the 'a' part was a ATI and Nvidia war going on
+		psVersions[2][5] = '0';
+		vsVersions[2][5] = '0';
+	}
 
 	return S_OK;
 }
@@ -522,16 +533,14 @@ D3DFORMAT GetSupportedDepthSurfaceFormat(D3DFORMAT target_format)
 
 const char *VertexShaderVersionString()
 {
-	static const char *versions[5] = {"ERROR", "vs_1_4", "vs_2_a", "vs_3_0", "vs_4_0"};
 	int version = ((D3D::caps.VertexShaderVersion >> 8) & 0xFF);
-	return versions[std::min(4, version)];
+	return vsVersions[std::min(4, version)];
 }
 
 const char *PixelShaderVersionString()
 {
-	static const char *versions[5] = {"ERROR", "ps_1_4", "ps_2_a", "ps_3_0", "ps_4_0"};
 	int version = ((D3D::caps.PixelShaderVersion >> 8) & 0xFF);
-	return versions[std::min(4, version)];
+	return psVersions[std::min(4, version)];
 }
 
 LPDIRECT3DSURFACE9 GetBackBufferSurface()
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.h b/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.h
index f4a5244dbe..d1e7eeaa91 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.h
@@ -47,6 +47,7 @@ namespace D3D
 #define FOURCC_NULL ((D3DFORMAT)(MAKEFOURCC('N','U','L','L')))
 
 bool IsATIDevice();
+bool IsIntelDevice();
 HRESULT Init();
 HRESULT Create(int adapter, HWND wnd, int resolution, int aa_mode, bool auto_depth);
 void Close();
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.cpp b/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.cpp
index cfb74df225..9510ad444c 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.cpp
@@ -383,7 +383,7 @@ void drawShadedTexQuad(IDirect3DTexture9 *texture,
 	float v2=((float)rSource->bottom) * sh;
 	float g = 1.0f/Gamma;
 
-	struct Q2DVertex { float x,y,z,rhw,u,v,w,h,G; } coords[4] = {
+	const struct Q2DVertex { float x,y,z,rhw,u,v,w,h,G; } coords[4] = {
 		{-1.0f - dw,-1.0f + dh, 0.0f,1.0f, u1, v2, sw, sh, g},
 		{-1.0f - dw, 1.0f + dh, 0.0f,1.0f, u1, v1, sw, sh, g},
 		{ 1.0f - dw,-1.0f + dh, 0.0f,1.0f, u2, v2, sw, sh, g},
@@ -434,15 +434,13 @@ void drawShadedTexSubQuad(IDirect3DTexture9 *texture,
 
 // Fills a certain area of the current render target with the specified color
 // Z buffer disabled; destination coordinates normalized to (-1;1)
-void drawColorQuad(int DestWidth, int DestHeight, u32 Color, float x1, float y1, float x2, float y2)
+void drawColorQuad(u32 Color, float x1, float y1, float x2, float y2)
 {
-	float dw = 1.f / (float)DestWidth;
-	float dh = 1.f / (float)DestHeight;
 	struct CQVertex { float x, y, z, rhw; u32 col; } coords[4] = {
-		{ x1-dw, y2+dh, 0.f, 1.f, Color },
-		{ x2-dw, y2+dh, 0.f, 1.f, Color },
-		{ x1-dw, y1+dh, 0.f, 1.f, Color },
-		{ x2-dw, y1+dh, 0.f, 1.f, Color },
+		{ x1, y2, 0.f, 1.f, Color },
+		{ x2, y2, 0.f, 1.f, Color },
+		{ x1, y1, 0.f, 1.f, Color },
+		{ x2, y1, 0.f, 1.f, Color },
 	};
 	dev->SetVertexShader(VertexShaderCache::GetClearVertexShader());
 	dev->SetPixelShader(PixelShaderCache::GetClearProgram());
@@ -451,15 +449,13 @@ void drawColorQuad(int DestWidth, int DestHeight, u32 Color, float x1, float y1,
 	RestoreShaders();
 }
 
-void drawClearQuad(int DestWidth, int DestHeight, u32 Color, float z, IDirect3DPixelShader9 *PShader, IDirect3DVertexShader9 *Vshader)
+void drawClearQuad(u32 Color,float z,IDirect3DPixelShader9 *PShader,IDirect3DVertexShader9 *Vshader)
 {
-	float dw = 1.f / (float)DestWidth;
-	float dh = 1.f / (float)DestHeight;
 	struct Q2DVertex { float x,y,z,rhw;u32 color;} coords[4] = {
-		{-1.0f-dw,  1.0f+dh, z, 1.0f, Color},
-		{ 1.0f-dw,  1.0f+dh, z, 1.0f, Color},
-		{ 1.0f-dw, -1.0f+dh, z, 1.0f, Color},
-		{-1.0f-dw, -1.0f+dh, z, 1.0f, Color}
+		{-1.0f,  1.0f, z, 1.0f, Color},
+		{ 1.0f,  1.0f, z, 1.0f, Color},
+		{ 1.0f, -1.0f, z, 1.0f, Color},
+		{-1.0f, -1.0f, z, 1.0f, Color}
 	};
 	dev->SetVertexShader(Vshader);
 	dev->SetPixelShader(PShader);
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.h b/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.h
index 93e60f938b..882f112ece 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.h
@@ -82,8 +82,8 @@ namespace D3D
 							IDirect3DPixelShader9 *PShader,
 							IDirect3DVertexShader9 *Vshader,
 							float Gamma = 1.0f);
-	void drawClearQuad(int DestWidth, int DestHeight, u32 Color, float z, IDirect3DPixelShader9 *PShader, IDirect3DVertexShader9 *Vshader);
-	void drawColorQuad(int DestWidth, int DestHeight, u32 Color, float x1, float y1, float x2, float y2);
+	void drawClearQuad(u32 Color, float z, IDirect3DPixelShader9 *PShader, IDirect3DVertexShader9 *Vshader);
+	void drawColorQuad(u32 Color, float x1, float y1, float x2, float y2);
 
 	void SaveRenderStates();
 	void RestoreRenderStates();
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp
index f76837837d..f66d096ab6 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp
@@ -43,6 +43,7 @@ namespace DX9
 
 PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
 const PixelShaderCache::PSCacheEntry *PixelShaderCache::last_entry;
+PIXELSHADERUID PixelShaderCache::last_uid;
 
 static LinearDiskCache<PIXELSHADERUID, u8> g_ps_disk_cache;
 static std::set<u32> unique_shaders;
@@ -233,6 +234,8 @@ static LPDIRECT3DPIXELSHADER9 CreateCopyShader(int copyMatrixType, int depthConv
 
 void PixelShaderCache::Init()
 {
+	last_entry = NULL;
+
 	//program used for clear screen
 	{
 		char pprog[3072];
@@ -283,6 +286,9 @@ void PixelShaderCache::Init()
 		SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
 	PixelShaderCacheInserter inserter;
 	g_ps_disk_cache.OpenAndRead(cache_filename, inserter);
+
+	if (g_Config.bEnableShaderDebugging)
+		Clear();
 }
 
 // ONLY to be used during shutdown.
@@ -292,7 +298,7 @@ void PixelShaderCache::Clear()
 		iter->second.Destroy();
 	PixelShaders.clear();
 
-	memset(&last_pixel_shader_uid, 0xFF, sizeof(last_pixel_shader_uid));
+	last_entry = NULL;
 }
 
 void PixelShaderCache::Shutdown()
@@ -326,41 +332,47 @@ void PixelShaderCache::Shutdown()
 
 bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 {
+	const API_TYPE api = ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30;
 	PIXELSHADERUID uid;
-	GetPixelShaderId(&uid, dstAlphaMode);
+	GetPixelShaderId(&uid, dstAlphaMode, components);
 
 	// Check if the shader is already set
-	if (uid == last_pixel_shader_uid && PixelShaders[uid].frameCount == frameCount)
+	if (last_entry)
 	{
-		PSCache::const_iterator iter = PixelShaders.find(uid);
-		GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-		return (iter != PixelShaders.end() && iter->second.shader);
+		if (uid == last_uid)
+		{
+			GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
+			ValidatePixelShaderIDs(api, last_entry->safe_uid, last_entry->code, dstAlphaMode, components);
+			return last_entry->shader != NULL;
+		}
 	}
 
-	memcpy(&last_pixel_shader_uid, &uid, sizeof(PIXELSHADERUID));
+	last_uid = uid;
 
 	// Check if the shader is already in the cache
 	PSCache::iterator iter;
 	iter = PixelShaders.find(uid);
 	if (iter != PixelShaders.end())
 	{
-		iter->second.frameCount = frameCount;
 		const PSCacheEntry &entry = iter->second;
 		last_entry = &entry;
 
 		if (entry.shader) D3D::SetPixelShader(entry.shader);
 		GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
+		ValidatePixelShaderIDs(api, entry.safe_uid, entry.code, dstAlphaMode, components);
 		return (entry.shader != NULL);
 	}
 
 
-
 	// Need to compile a new shader
-	const char *code = GeneratePixelShaderCode(dstAlphaMode, ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30, components);
+	const char *code = GeneratePixelShaderCode(dstAlphaMode, api, components);
 
-	u32 code_hash = HashAdler32((const u8 *)code, strlen(code));
-	unique_shaders.insert(code_hash);
-	SETSTAT(stats.numUniquePixelShaders, unique_shaders.size());
+	if (g_ActiveConfig.bEnableShaderDebugging)
+	{
+		u32 code_hash = HashAdler32((const u8 *)code, strlen(code));
+		unique_shaders.insert(code_hash);
+		SETSTAT(stats.numUniquePixelShaders, unique_shaders.size());
+	}
 
 #if defined(_DEBUG) || defined(DEBUGFAST)
 	if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) {
@@ -381,14 +393,19 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 
 	// Insert the bytecode into the caches
 	g_ps_disk_cache.Append(uid, bytecode, bytecodelen);
-	g_ps_disk_cache.Sync();
 
 	// And insert it into the shader cache.
-	bool result = InsertByteCode(uid, bytecode, bytecodelen, true);
+	bool success = InsertByteCode(uid, bytecode, bytecodelen, true);
 	delete [] bytecode;
 
+	if (g_ActiveConfig.bEnableShaderDebugging && success)
+	{
+		PixelShaders[uid].code = code;
+		GetSafePixelShaderId(&PixelShaders[uid].safe_uid, dstAlphaMode, components);
+	}
+
 	GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-	return result;
+	return success;
 }
 
 bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate)
@@ -398,7 +415,6 @@ bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const u8 *bytec
 	// Make an entry in the table
 	PSCacheEntry newentry;
 	newentry.shader = shader;
-	newentry.frameCount = frameCount;
 	PixelShaders[uid] = newentry;
 	last_entry = &PixelShaders[uid];
 
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.h b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.h
index 2f3c552e2a..c771984d36 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.h
@@ -40,9 +40,11 @@ private:
 	{
 		LPDIRECT3DPIXELSHADER9 shader;
 		bool owns_shader;
-		int frameCount;
 
-		PSCacheEntry() : shader(NULL), owns_shader(true), frameCount(0) {}
+		PIXELSHADERUIDSAFE safe_uid;
+		std::string code;
+
+		PSCacheEntry() : shader(NULL), owns_shader(true) {}
 		void Destroy()
 		{
 			if (shader && owns_shader)
@@ -55,6 +57,7 @@ private:
 
 	static PSCache PixelShaders;
 	static const PSCacheEntry *last_entry;
+	static PIXELSHADERUID last_uid;
 	static void Clear();
 
 public:
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/Render.cpp b/Source/Plugins/Plugin_VideoDX9/Src/Render.cpp
index e333cbc168..a5aaa6485b 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/Render.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/Render.cpp
@@ -53,18 +53,13 @@
 #include "Debugger.h"
 #include "Core.h"
 #include "Movie.h"
+#include "BPFunctions.h"
 
 namespace DX9
 {
 
 static int s_fps = 0;
 
-static int s_recordWidth;
-static int s_recordHeight;
-
-static bool s_bLastFrameDumped;
-static bool s_bAVIDumping;
-
 static u32 s_blendMode;
 static u32 s_LastAA;
 static bool IS_AMD;
@@ -296,9 +291,6 @@ Renderer::Renderer()
 	// Make sure to use valid texture sizes
 	D3D::FixTextureSize(s_target_width, s_target_height);
 
-	s_bLastFrameDumped = false;
-	s_bAVIDumping = false;
-
 	// We're not using fixed function.
 	// Let's just set the matrices to identity to be sure.
 	D3DXMATRIX mtx;
@@ -341,10 +333,6 @@ Renderer::~Renderer()
 	D3D::Present();
 	D3D::Close();
 	
-	if (s_bAVIDumping)
-	{
-		AVIDump::Stop();
-	}
 	delete[] st;
 }
 
@@ -426,55 +414,9 @@ bool Renderer::CheckForResize()
 	return false;
 }
 
-bool Renderer::SetScissorRect()
+void Renderer::SetScissorRect(const TargetRectangle& rc)
 {
-	TargetRectangle rc;
-	GetScissorRect(rc);
-
-	if (rc.left < 0) rc.left = 0;
-	if (rc.right < 0) rc.right = 0;
-	if (rc.top < 0) rc.top = 0;
-	if (rc.bottom < 0) rc.bottom = 0;
-
-	if (rc.left > EFB_WIDTH) rc.left = EFB_WIDTH;
-	if (rc.right > EFB_WIDTH) rc.right = EFB_WIDTH;
-	if (rc.top > EFB_HEIGHT) rc.top = EFB_HEIGHT;
-	if (rc.bottom > EFB_HEIGHT) rc.bottom = EFB_HEIGHT;
-
-	if (rc.left > rc.right)
-	{
-		int temp = rc.right;
-		rc.right = rc.left;
-		rc.left = temp;
-	}
-	if (rc.top > rc.bottom)
-	{
-		int temp = rc.bottom;
-		rc.bottom = rc.top;
-		rc.top = temp;
-	}
-
-	rc.left   = EFBToScaledX(rc.left);
-	rc.top    = EFBToScaledY(rc.top);
-	rc.right  = EFBToScaledX(rc.right);
-	rc.bottom = EFBToScaledY(rc.bottom);
-
-	// Check that the coordinates are good
-	if (rc.right != rc.left && rc.bottom != rc.top)
-	{
-		D3D::dev->SetScissorRect(rc.AsRECT());
-		return true;
-	}
-	else
-	{
-		//WARN_LOG(VIDEO, "Bad scissor rectangle: %i %i %i %i", rc.left, rc.top, rc.right, rc.bottom);
-		rc.left   = 0;
-		rc.top    = 0;
-		rc.right  = s_target_width;
-		rc.bottom = s_target_height;
-		D3D::dev->SetScissorRect(rc.AsRECT());
-	}
-	return false;
+	D3D::dev->SetScissorRect(rc.AsRECT());
 }
 
 void Renderer::SetColorMask()
@@ -680,7 +622,7 @@ u32 Renderer::AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data)
 	{
 		// TODO: Speed this up by batching pokes?
 		ResetAPIState();
-		D3D::drawColorQuad(GetTargetWidth(), GetTargetHeight(), poke_data,
+		D3D::drawColorQuad(poke_data,
 							  (float)RectToLock.left   * 2.f / (float)Renderer::GetTargetWidth()  - 1.f,
 							- (float)RectToLock.top    * 2.f / (float)Renderer::GetTargetHeight() + 1.f,
 							  (float)RectToLock.right  * 2.f / (float)Renderer::GetTargetWidth()  - 1.f,
@@ -805,7 +747,7 @@ void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaE
 	vp.MinZ = 0.0;
 	vp.MaxZ = 1.0;
 	D3D::dev->SetViewport(&vp);
-	D3D::drawClearQuad(GetTargetWidth(), GetTargetHeight(), color, (z & 0xFFFFFF) / float(0xFFFFFF), PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
+	D3D::drawClearQuad(color, (z & 0xFFFFFF) / float(0xFFFFFF), PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
 	RestoreAPIState();
 }
 
@@ -819,7 +761,7 @@ void Renderer::ReinterpretPixelData(unsigned int convtype)
 	else if (convtype == 2) pixel_shader = PixelShaderCache::ReinterpRGBA6ToRGB8();
 	else
 	{
-		PanicAlert("Trying to reinterpret pixel data with unsupported conversion type %d", convtype);
+		ERROR_LOG(VIDEO, "Trying to reinterpret pixel data with unsupported conversion type %d", convtype);
 		return;
 	}
 
@@ -889,12 +831,11 @@ bool Renderer::SaveScreenshot(const std::string &filename, const TargetRectangle
 // This function has the final picture. We adjust the aspect ratio here.
 void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,const EFBRectangle& rc,float Gamma)
 {
-	static char* data = 0;
-	static int w = 0, h = 0;
 	if (g_bSkipCurrentFrame || (!XFBWrited && (!g_ActiveConfig.bUseXFB || !g_ActiveConfig.bUseRealXFB)) || !fbWidth || !fbHeight)
 	{
-		if (g_ActiveConfig.bDumpFrames && data)
-			AVIDump::AddFrame(data);
+		if (g_ActiveConfig.bDumpFrames && frame_data)
+			AVIDump::AddFrame(frame_data);
+
 		Core::Callback_VideoCopiedToXFB(false);
 		return;
 	}
@@ -907,6 +848,9 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 	const XFBSourceBase* const* xfbSourceList = FramebufferManager::GetXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
 	if ((!xfbSourceList || xfbCount == 0) && g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
 	{
+		if (g_ActiveConfig.bDumpFrames && frame_data)
+			AVIDump::AddFrame(frame_data);
+
 		Core::Callback_VideoCopiedToXFB(false);
 		return;
 	}
@@ -952,7 +896,7 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 		vp.MinZ = 0.0f;
 		vp.MaxZ = 1.0f;
 		D3D::dev->SetViewport(&vp);
-		D3D::drawClearQuad(GetTargetWidth(), GetTargetHeight(), 0, 1.0, PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
+		D3D::drawClearQuad(0, 1.0, PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
 	}
 	else
 	{
@@ -1072,15 +1016,21 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 		SaveScreenshot(s_sScreenshotName, dst_rect);
 		s_bScreenshot = false;
 	}
+
+	// Dump frames
+	static int w = 0, h = 0;
 	if (g_ActiveConfig.bDumpFrames)
 	{
+		static int s_recordWidth;
+		static int s_recordHeight;
+
 		HRESULT hr = D3D::dev->GetRenderTargetData(D3D::GetBackBufferSurface(),ScreenShootMEMSurface);
-		if (!s_bLastFrameDumped)
+		if (!bLastFrameDumped)
 		{
 			s_recordWidth = dst_rect.GetWidth();
 			s_recordHeight = dst_rect.GetHeight();
-			s_bAVIDumping = AVIDump::Start(EmuWindow::GetParentWnd(), s_recordWidth, s_recordHeight);
-			if (!s_bAVIDumping)
+			bAVIDumping = AVIDump::Start(EmuWindow::GetParentWnd(), s_recordWidth, s_recordHeight);
+			if (!bAVIDumping)
 			{
 				PanicAlert("Error dumping frames to AVI.");
 			}
@@ -1092,40 +1042,40 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 				OSD::AddMessage(msg, 2000);
 			}
 		}
-		if (s_bAVIDumping)
+		if (bAVIDumping)
 		{
 			D3DLOCKED_RECT rect;
 			if (SUCCEEDED(ScreenShootMEMSurface->LockRect(&rect, dst_rect.AsRECT(), D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_NOSYSLOCK | D3DLOCK_READONLY)))
 			{
-				if (!data || w != s_recordWidth || h != s_recordHeight)
+				if (!frame_data || w != s_recordWidth || h != s_recordHeight)
 				{
-					free(data);
-					data = (char*)malloc(3 * s_recordWidth * s_recordHeight);
+					delete[] frame_data;
+					frame_data = new char[3 * s_recordWidth * s_recordHeight];
 					w = s_recordWidth;
 					h = s_recordHeight;
 				}
-				formatBufferDump((const char*)rect.pBits, data, s_recordWidth, s_recordHeight, rect.Pitch);
-				AVIDump::AddFrame(data);
+				formatBufferDump((const char*)rect.pBits, frame_data, s_recordWidth, s_recordHeight, rect.Pitch);
+				AVIDump::AddFrame(frame_data);
 				ScreenShootMEMSurface->UnlockRect();
 			}
 		}
-		s_bLastFrameDumped = true;
+		bLastFrameDumped = true;
 	}
 	else
 	{
-		if (s_bLastFrameDumped && s_bAVIDumping)
+		if (bLastFrameDumped && bAVIDumping)
 		{
-			if (data)
+			if (frame_data)
 			{
-				free(data);
-				data = 0;
+				delete[] frame_data;
+				frame_data = 0;
 				w = h = 0;
 			}
 			AVIDump::Stop();
-			s_bAVIDumping = false;
+			bAVIDumping = false;
 			OSD::AddMessage("Stop dumping frames to AVI", 2000);
 		}
-		s_bLastFrameDumped = false;
+		bLastFrameDumped = false;
 	}
 
 	// Finish up the current frame, print some stats
@@ -1164,12 +1114,11 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 	DLCache::ProgressiveCleanup();
 	TextureCache::Cleanup();
 
-	// reload textures if these settings changed
-	if (g_Config.bSafeTextureCache != g_ActiveConfig.bSafeTextureCache ||
-		g_Config.bUseNativeMips != g_ActiveConfig.bUseNativeMips)
+	// Reload textures if these settings changed
+	if (g_Config.bUseNativeMips != g_ActiveConfig.bUseNativeMips)
 		TextureCache::Invalidate(false);
 
-	// Enable any configuration changes
+	// Enable configuration changes
 	UpdateActiveConfig();
 
 	SetWindowSize(fbWidth, fbHeight);
@@ -1293,7 +1242,7 @@ void Renderer::RestoreAPIState()
 	D3D::SetRenderState(D3DRS_FILLMODE, g_ActiveConfig.bWireFrame ? D3DFILL_WIREFRAME : D3DFILL_SOLID);
 	D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
 	VertexShaderManager::SetViewportChanged();
-	SetScissorRect();
+	BPFunctions::SetScissor();
 	if (bpmem.zmode.testenable) {
 		D3D::SetRenderState(D3DRS_ZENABLE, TRUE);
 		if (bpmem.zmode.updateenable)
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/Render.h b/Source/Plugins/Plugin_VideoDX9/Src/Render.h
index b3c89f82f9..6e5198b3cd 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/Render.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/Render.h
@@ -15,7 +15,7 @@ public:
 
 	void SetColorMask();
 	void SetBlendMode(bool forceUpdate);
-	bool SetScissorRect();
+	void SetScissorRect(const TargetRectangle& rc);
 	void SetGenerationMode();
 	void SetDepthMode();
 	void SetLogicOpMode();
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp b/Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp
index 7c741e08a9..2a3f12ddcf 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp
@@ -21,6 +21,7 @@
 #include "Statistics.h"
 #include "MemoryUtil.h"
 #include "Hash.h"
+#include "HW/Memmap.h"
 
 #include "CommonPaths.h"
 #include "FileUtil.h"
@@ -78,7 +79,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 		FramebufferManager::GetEFBDepthTexture() :
 		FramebufferManager::GetEFBColorTexture();
 
-	if (!isDynamic || g_ActiveConfig.bCopyEFBToTexture)
+	if (type != TCET_EC_DYNAMIC || g_ActiveConfig.bCopyEFBToTexture)
 	{
 		LPDIRECT3DSURFACE9 Rendersurf = NULL;
 		texture->GetSurfaceLevel(0, &Rendersurf);
@@ -90,15 +91,15 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 		// Stretch picture with increased internal resolution
 		vp.X = 0;
 		vp.Y = 0;
-		vp.Width  = virtualW;
-		vp.Height = virtualH;
+		vp.Width  = virtual_width;
+		vp.Height = virtual_height;
 		vp.MinZ = 0.0f;
 		vp.MaxZ = 1.0f;
 		D3D::dev->SetViewport(&vp);
 		RECT destrect;
-		destrect.bottom = virtualH;
+		destrect.bottom = virtual_height;
 		destrect.left = 0;
-		destrect.right = virtualW;
+		destrect.right = virtual_width;
 		destrect.top = 0;
 
 		PixelShaderManager::SetColorMatrix(colmat); // set transformation
@@ -133,7 +134,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 
 		D3D::drawShadedTexQuad(read_texture, &sourcerect, 
 			Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
-			virtualW, virtualH,
+			virtual_width, virtual_height,
 			// TODO: why is D3DFMT_D24X8 singled out here? why not D3DFMT_D24X4S4/D24S8/D24FS8/D32/D16/D15S1 too, or none of them?
 			PixelShaderCache::GetDepthMatrixProgram(SSAAMode, (srcFormat == PIXELFMT_Z24) && bformat != FOURCC_RAWZ && bformat != D3DFMT_D24X8),
 			VertexShaderCache::GetSimpleVertexShader(SSAAMode));
@@ -143,16 +144,25 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 
 	if (!g_ActiveConfig.bCopyEFBToTexture)
 	{
-		hash = TextureConverter::EncodeToRamFromTexture(
-			addr,
-			read_texture,
-			Renderer::GetTargetWidth(), 
-			Renderer::GetTargetHeight(),
-			srcFormat == PIXELFMT_Z24, 
-			isIntensity, 
-			dstFormat, 
-			scaleByHalf, 
-			srcRect);
+		int encoded_size = TextureConverter::EncodeToRamFromTexture(
+					addr,
+					read_texture,
+					Renderer::GetTargetWidth(), 
+					Renderer::GetTargetHeight(),
+					srcFormat == PIXELFMT_Z24, 
+					isIntensity, 
+					dstFormat, 
+					scaleByHalf, 
+					srcRect);
+
+		u8* dst = Memory::GetPointer(addr);
+		hash = GetHash64(dst,encoded_size,g_ActiveConfig.iSafeTextureCache_ColorSamples);
+
+		// Mark texture entries in destination address range dynamic unless caching is enabled and the texture entry is up to date
+		if (!g_ActiveConfig.bEFBCopyCacheEnable)
+			TextureCache::MakeRangeDynamic(addr,encoded_size);
+		else if (!TextureCache::Find(addr, hash))
+			TextureCache::MakeRangeDynamic(addr,encoded_size);
 	}
 	
 	D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.cpp b/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.cpp
index d14a3f29ea..7c38b154b9 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.cpp
@@ -252,10 +252,10 @@ void EncodeToRamUsingShader(LPDIRECT3DPIXELSHADER9 shader, LPDIRECT3DTEXTURE9 sr
 
 	s_texConvReadSurface = TrnBuffers[index].ReadSurface;
 	Rendersurf = TrnBuffers[index].RenderSurface;
-	
+
 	hr = D3D::dev->SetDepthStencilSurface(NULL);
 	hr = D3D::dev->SetRenderTarget(0, Rendersurf);	
-	
+
 	if (linearFilter)
 	{
 		D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
@@ -290,7 +290,7 @@ void EncodeToRamUsingShader(LPDIRECT3DPIXELSHADER9 shader, LPDIRECT3DTEXTURE9 sr
 	D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
 	// .. and then read back the results.
 	// TODO: make this less slow.
-	
+
 	hr = D3D::dev->GetRenderTargetData(Rendersurf,s_texConvReadSurface);
 
 	D3DLOCKED_RECT drect;
@@ -313,76 +313,7 @@ void EncodeToRamUsingShader(LPDIRECT3DPIXELSHADER9 shader, LPDIRECT3DTEXTURE9 sr
 	hr = s_texConvReadSurface->UnlockRect();
 }
 
-void EncodeToRam(u32 address, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle& source)
-{
-	u32 format = copyfmt;
-
-	if (bFromZBuffer)
-	{
-		format |= _GX_TF_ZTF;
-		if (copyfmt == 11)
-			format = GX_TF_Z16;
-		else if (format < GX_TF_Z8 || format > GX_TF_Z24X8)
-			format |= _GX_TF_CTF;
-	}
-	else
-		if (copyfmt > GX_TF_RGBA8 || (copyfmt < GX_TF_RGB565 && !bIsIntensityFmt))
-			format |= _GX_TF_CTF;
-
-	LPDIRECT3DPIXELSHADER9 texconv_shader = GetOrCreateEncodingShader(format);
-	if (!texconv_shader)
-		return;
-
-	u8 *dest_ptr = Memory::GetPointer(address);
-
-	LPDIRECT3DTEXTURE9 source_texture = bFromZBuffer ? FramebufferManager::GetEFBDepthTexture() : FramebufferManager::GetEFBColorTexture();
-	int width = (source.right - source.left) >> bScaleByHalf;
-	int height = (source.bottom - source.top) >> bScaleByHalf;
-
-	int size_in_bytes = TexDecoder_GetTextureSizeInBytes(width, height, format);
-
-	// Invalidate any existing texture covering this memory range.
-	// TODO - don't delete the texture if it already exists, just replace the contents.
-	TextureCache::InvalidateRange(address, size_in_bytes);
-	
-	u16 blkW = TexDecoder_GetBlockWidthInTexels(format) - 1;
-	u16 blkH = TexDecoder_GetBlockHeightInTexels(format) - 1;	
-	u16 samples = TextureConversionShader::GetEncodedSampleCount(format);	
-
-	// only copy on cache line boundaries
-	// extra pixels are copied but not displayed in the resulting texture
-	s32 expandedWidth = (width + blkW) & (~blkW);
-	s32 expandedHeight = (height + blkH) & (~blkH);
-
-	float sampleStride = bScaleByHalf ? 2.f : 1.f;
-	TextureConversionShader::SetShaderParameters(
-		(float)expandedWidth,
-		(float)Renderer::EFBToScaledY(expandedHeight), // TODO: Why do we scale this?
-		(float)Renderer::EFBToScaledX(source.left),
-		(float)Renderer::EFBToScaledY(source.top),
-		Renderer::EFBToScaledXf(sampleStride),
-		Renderer::EFBToScaledYf(sampleStride),
-		(float)Renderer::GetTargetWidth(),
-		(float)Renderer::GetTargetHeight());
-
-	TargetRectangle scaledSource;
-	scaledSource.top = 0;
-	scaledSource.bottom = expandedHeight;
-	scaledSource.left = 0;
-	scaledSource.right = expandedWidth / samples;
-	int cacheBytes = 32;
-    if ((format & 0x0f) == 6)
-        cacheBytes = 64;
-
-    int readStride = (expandedWidth * cacheBytes) / TexDecoder_GetBlockWidthInTexels(format);
-	g_renderer->ResetAPIState();
-	EncodeToRamUsingShader(texconv_shader, source_texture, scaledSource, dest_ptr, expandedWidth / samples, expandedHeight, readStride, true, bScaleByHalf > 0,1.0f);
-	D3D::dev->SetRenderTarget(0, FramebufferManager::GetEFBColorRTSurface());
-	D3D::dev->SetDepthStencilSurface(FramebufferManager::GetEFBDepthRTSurface());
-	g_renderer->RestoreAPIState();
-}
-
-u64 EncodeToRamFromTexture(u32 address,LPDIRECT3DTEXTURE9 source_texture, u32 SourceW, u32 SourceH, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle& source)
+int EncodeToRamFromTexture(u32 address,LPDIRECT3DTEXTURE9 source_texture, u32 SourceW, u32 SourceH, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle& source)
 {
 	u32 format = copyfmt;
 
@@ -440,16 +371,7 @@ u64 EncodeToRamFromTexture(u32 address,LPDIRECT3DTEXTURE9 source_texture, u32 So
 
     int readStride = (expandedWidth * cacheBytes) / TexDecoder_GetBlockWidthInTexels(format);
 	EncodeToRamUsingShader(texconv_shader, source_texture, scaledSource, dest_ptr, expandedWidth / samples, expandedHeight, readStride, true, bScaleByHalf > 0,1.0f);
-	u64 hash = GetHash64(dest_ptr,size_in_bytes,g_ActiveConfig.iSafeTextureCache_ColorSamples);
-	if (g_ActiveConfig.bEFBCopyCacheEnable)
-	{
-		// If the texture in RAM is already in the texture cache, do not copy it again as it has not changed.
-		if (TextureCache::Find(address, hash))
-			return hash;
-	}
-
-	TextureCache::MakeRangeDynamic(address,size_in_bytes);
-	return hash;
+	return size_in_bytes; // TODO: D3D11 is calculating this value differently!
 }
 
 void EncodeToRamYUYV(LPDIRECT3DTEXTURE9 srcTexture, const TargetRectangle& sourceRc, u8* destAddr, int dstWidth, int dstHeight,float Gamma)
@@ -490,7 +412,7 @@ void DecodeToTexture(u32 xfbAddr, int srcWidth, int srcHeight, LPDIRECT3DTEXTURE
 	destTexture->GetSurfaceLevel(0,&Rendersurf);
 	D3D::dev->SetDepthStencilSurface(NULL);
 	D3D::dev->SetRenderTarget(0, Rendersurf);
-    
+
 	D3DVIEWPORT9 vp;
 
 	// Stretch picture with increased internal resolution
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.h b/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.h
index aa4757e4c9..4036f21447 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.h
@@ -35,15 +35,13 @@ namespace TextureConverter
 void Init();
 void Shutdown();
 
-void EncodeToRam(u32 address, bool bFromZBuffer, bool bIsIntensityFmt,
-				 u32 copyfmt, int bScaleByHalf, const EFBRectangle& source);
-
 void EncodeToRamYUYV(LPDIRECT3DTEXTURE9 srcTexture, const TargetRectangle& sourceRc,
 					 u8* destAddr, int dstWidth, int dstHeight,float Gamma);
 
 void DecodeToTexture(u32 xfbAddr, int srcWidth, int srcHeight, LPDIRECT3DTEXTURE9 destTexture);
 
-u64 EncodeToRamFromTexture(u32 address,LPDIRECT3DTEXTURE9 source_texture, u32 SourceW, u32 SourceH, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle& source);
+// returns size of the encoded data (in bytes)
+int EncodeToRamFromTexture(u32 address,LPDIRECT3DTEXTURE9 source_texture, u32 SourceW, u32 SourceH, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle& source);
 
 
 }
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp b/Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp
index d9c33b67ef..2083d4f1d8 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp
@@ -137,12 +137,13 @@ void VertexManager::vFlush()
 				tex.texImage0[i&3].format, tex.texTlut[i&3].tmem_offset<<9, 
 				tex.texTlut[i&3].tlut_format,
 				(tex.texMode0[i&3].min_filter & 3) && (tex.texMode0[i&3].min_filter != 8) && g_ActiveConfig.bUseNativeMips,
-				(tex.texMode1[i&3].max_lod >> 4));
+				tex.texMode1[i&3].max_lod >> 4,
+				tex.texImage1[i&3].image_type);
 
 			if (tentry)
 			{
 				// 0s are probably for no manual wrapping needed.
-				PixelShaderManager::SetTexDims(i, tentry->realW, tentry->realH, 0, 0);
+				PixelShaderManager::SetTexDims(i, tentry->native_width, tentry->native_height, tentry->virtual_width, tentry->virtual_height, 0, 0, API_D3D9);
 			}
 			else
 				ERROR_LOG(VIDEO, "error loading texture");
@@ -151,7 +152,7 @@ void VertexManager::vFlush()
 
 	// set global constants
 	VertexShaderManager::SetConstants();
-	PixelShaderManager::SetConstants();
+	PixelShaderManager::SetConstants(API_D3D9);
 
 	if (!PixelShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components))
 	{
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp
index 5fc2b6dee2..e392cf3de0 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp
@@ -38,6 +38,7 @@ namespace DX9
 
 VertexShaderCache::VSCache VertexShaderCache::vshaders;
 const VertexShaderCache::VSCacheEntry *VertexShaderCache::last_entry;
+VERTEXSHADERUID VertexShaderCache::last_uid;
 
 #define MAX_SSAA_SHADERS 3
 
@@ -151,6 +152,11 @@ void VertexShaderCache::Init()
 			SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
 	VertexShaderCacheInserter inserter;
 	g_vs_disk_cache.OpenAndRead(cache_filename, inserter);
+
+	if (g_Config.bEnableShaderDebugging)
+		Clear();
+
+	last_entry = NULL;
 }
 
 void VertexShaderCache::Clear()
@@ -159,7 +165,7 @@ void VertexShaderCache::Clear()
 		iter->second.Destroy();
 	vshaders.clear();
 
-	memset(&last_vertex_shader_uid, 0xFF, sizeof(last_vertex_shader_uid));
+	last_entry = NULL;
 }
 
 void VertexShaderCache::Shutdown()
@@ -184,23 +190,27 @@ bool VertexShaderCache::SetShader(u32 components)
 {
 	VERTEXSHADERUID uid;
 	GetVertexShaderId(&uid, components);
-	if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount)
+	if (last_entry)
 	{
-		GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-		return (vshaders[uid].shader != NULL);
+		if (uid == last_uid)
+		{
+			GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
+			ValidateVertexShaderIDs(API_D3D9, last_entry->safe_uid, last_entry->code, components);
+			return (last_entry->shader != NULL);
+		}
 	}
 
-	memcpy(&last_vertex_shader_uid, &uid, sizeof(VERTEXSHADERUID));
+	last_uid = uid;
 
 	VSCache::iterator iter = vshaders.find(uid);
 	if (iter != vshaders.end())
 	{
-		iter->second.frameCount = frameCount;
 		const VSCacheEntry &entry = iter->second;
 		last_entry = &entry;
 
 		if (entry.shader) D3D::SetVertexShader(entry.shader);
 		GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
+		ValidateVertexShaderIDs(API_D3D9, entry.safe_uid, entry.code, components);
 		return (entry.shader != NULL);
 	}
 
@@ -213,12 +223,16 @@ bool VertexShaderCache::SetShader(u32 components)
 		return false;
 	}
 	g_vs_disk_cache.Append(uid, bytecode, bytecodelen);
-	g_vs_disk_cache.Sync();
 
-	bool result = InsertByteCode(uid, bytecode, bytecodelen, true);
+	bool success = InsertByteCode(uid, bytecode, bytecodelen, true);
+	if (g_ActiveConfig.bEnableShaderDebugging && success)
+	{
+		vshaders[uid].code = code;
+		GetSafeVertexShaderId(&vshaders[uid].safe_uid, components);
+	}
 	delete [] bytecode;
 	GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-	return result;
+	return success;
 }
 
 bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate) {
@@ -227,7 +241,6 @@ bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, const u8 *byt
 	// Make an entry in the table
 	VSCacheEntry entry;
 	entry.shader = shader;
-	entry.frameCount = frameCount;
 
 	vshaders[uid] = entry;
 	last_entry = &vshaders[uid];
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.h b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.h
index b516f46f9a..c9c447e35b 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.h
+++ b/Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.h
@@ -34,11 +34,11 @@ private:
 	struct VSCacheEntry
 	{ 
 		LPDIRECT3DVERTEXSHADER9 shader;
-		int frameCount;
-#if defined(_DEBUG) || defined(DEBUGFAST)
+
 		std::string code;
-#endif
-		VSCacheEntry() : shader(NULL), frameCount(0) {}
+		VERTEXSHADERUIDSAFE safe_uid;
+
+		VSCacheEntry() : shader(NULL) {}
 		void Destroy()
 		{
 			if (shader)
@@ -51,6 +51,7 @@ private:
 
 	static VSCache vshaders;
 	static const VSCacheEntry *last_entry;
+	static VERTEXSHADERUID last_uid;
 	static void Clear();
 
 public:
diff --git a/Source/Plugins/Plugin_VideoDX9/Src/main.cpp b/Source/Plugins/Plugin_VideoDX9/Src/main.cpp
index 1d733f7dc3..6c52219f97 100644
--- a/Source/Plugins/Plugin_VideoDX9/Src/main.cpp
+++ b/Source/Plugins/Plugin_VideoDX9/Src/main.cpp
@@ -78,7 +78,7 @@ void VideoBackend::UpdateFPSDisplay(const char *text)
 {
 	TCHAR temp[512];
 	swprintf_s(temp, sizeof(temp)/sizeof(TCHAR), _T("%hs | DX9 | %hs"), scm_rev_str, text);
-	SetWindowText(EmuWindow::GetWnd(), temp);
+	EmuWindow::SetWindowText(temp);
 }
 
 std::string VideoBackend::GetName()
@@ -132,6 +132,7 @@ void VideoBackend::ShowConfig(void* parent)
 
 bool VideoBackend::Initialize(void *&window_handle)
 {
+	InitializeShared();
 	InitBackendInfo();
 
 	frameCount = 0;