merge Vertex and PixelShaderCache into ProgramShaderCache

this is the first step, uniform handling is still missing

15 files changed, 368 insertions, 695 deletions

diff --git a/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj b/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj
index c5e741a66b..e0458d9a01 100644
--- a/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj
+++ b/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj
@@ -224,7 +224,6 @@
     <ClInclude Include="Src\Globals.h" />
     <ClInclude Include="Src\GLUtil.h" />
     <ClInclude Include="Src\main.h" />
-    <ClInclude Include="Src\PixelShaderCache.h" />
     <ClInclude Include="Src\PostProcessing.h" />
     <ClInclude Include="Src\ProgramShaderCache.h" />
     <ClInclude Include="Src\RasterFont.h" />
@@ -234,7 +233,6 @@
     <ClInclude Include="Src\TextureCache.h" />
     <ClInclude Include="Src\TextureConverter.h" />
     <ClInclude Include="Src\VertexManager.h" />
-    <ClInclude Include="Src\VertexShaderCache.h" />
     <ClInclude Include="Src\VideoBackend.h" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj.filters b/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj.filters
index 3437f0a8ae..27bb563c52 100644
--- a/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj.filters
+++ b/Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj.filters
@@ -63,9 +63,6 @@
     <ClInclude Include="Src\FramebufferManager.h">
       <Filter>Render</Filter>
     </ClInclude>
-    <ClInclude Include="Src\PixelShaderCache.h">
-      <Filter>Render</Filter>
-    </ClInclude>
     <ClInclude Include="Src\PostProcessing.h">
       <Filter>Render</Filter>
     </ClInclude>
@@ -78,9 +75,6 @@
     <ClInclude Include="Src\TextureCache.h">
       <Filter>Render</Filter>
     </ClInclude>
-    <ClInclude Include="Src\VertexShaderCache.h">
-      <Filter>Render</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="CMakeLists.txt" />
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp
index eaf3562986..1d3865851a 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp
@@ -28,7 +28,6 @@
 #include "Render.h"
 #include "VertexShaderGen.h"
 #include "ProgramShaderCache.h"
-#include "PixelShaderCache.h"
 #include "PixelShaderManager.h"
 #include "OnScreenDisplay.h"
 #include "StringUtil.h"
@@ -38,136 +37,6 @@
 namespace OGL
 {
 
-static int s_nMaxPixelInstructions;
-PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
-PIXELSHADERUID PixelShaderCache::s_curuid;
-bool PixelShaderCache::s_displayCompileAlert;
-GLuint PixelShaderCache::CurrentShader;
-bool PixelShaderCache::ShaderEnabled;
-
-PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry = NULL;
-PIXELSHADERUID PixelShaderCache::last_uid;
-
-void PixelShaderCache::Init()
-{
-	ShaderEnabled = true;
-	CurrentShader = 0;
-	last_entry = NULL;
-	GL_REPORT_ERRORD();
-
-	s_displayCompileAlert = true;
-}
-
-void PixelShaderCache::Shutdown()
-{
-	PSCache::iterator iter = PixelShaders.begin();
-	for (; iter != PixelShaders.end(); iter++)
-		iter->second.Destroy();
-	PixelShaders.clear();
-}
-
-FRAGMENTSHADER* PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
-{
-	PIXELSHADERUID uid;
-	GetPixelShaderId(&uid, dstAlphaMode, components);
-
-	// Check if the shader is already set
-	if (last_entry)
-	{
-		if (uid == last_uid)
-		{
-			GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-			ValidatePixelShaderIDs(API_OPENGL, last_entry->safe_uid, last_entry->shader.strprog, dstAlphaMode, components);
-			return &last_entry->shader;
-		}
-	}
-
-	last_uid = uid;
-
-	PSCache::iterator iter = PixelShaders.find(uid);
-	if (iter != PixelShaders.end())
-	{
-		PSCacheEntry &entry = iter->second;
-		last_entry = &entry;
-
-		GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-		ValidatePixelShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, dstAlphaMode, components);
-		return &last_entry->shader;
-	}
-
-	// Make an entry in the table
-	PSCacheEntry& newentry = PixelShaders[uid];
-	last_entry = &newentry;
-	const char *code = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components);
-
-	if (g_ActiveConfig.bEnableShaderDebugging && code)
-	{
-		GetSafePixelShaderId(&newentry.safe_uid, dstAlphaMode, components);
-		newentry.shader.strprog = code;
-	}
-
-#if defined(_DEBUG) || defined(DEBUGFAST)
-	if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) {
-		static int counter = 0;
-		char szTemp[MAX_PATH];
-		sprintf(szTemp, "%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
-
-		SaveData(szTemp, code);
-	}
-#endif
-
-	if (!code || !CompilePixelShader(newentry.shader, code)) {
-		GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
-		return NULL;
-	}
-
-	INCSTAT(stats.numPixelShadersCreated);
-	SETSTAT(stats.numPixelShadersAlive, PixelShaders.size());
-	GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-	return &last_entry->shader;
-}
-
-bool PixelShaderCache::CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrprogram)
-{
-	GLuint result = glCreateShader(GL_FRAGMENT_SHADER);
-
-	glShaderSource(result, 1, &pstrprogram, NULL);
-	glCompileShader(result);
-#if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
-	GLsizei length = 0;
-	glGetShaderiv(result, GL_INFO_LOG_LENGTH, &length);
-	if (length > 1)
-	{
-		GLsizei charsWritten;
-		GLchar* infoLog = new GLchar[length];
-		glGetShaderInfoLog(result, length, &charsWritten, infoLog);
-		ERROR_LOG(VIDEO, "PS Shader info log:\n%s", infoLog);
-		char szTemp[MAX_PATH];
-		sprintf(szTemp, "ps_%d.txt", result);
-		FILE *fp = fopen(szTemp, "wb");
-		fwrite(infoLog, strlen(infoLog), 1, fp);
-		fwrite(pstrprogram, strlen(pstrprogram), 1, fp);
-		fclose(fp);
-		delete[] infoLog;
-	}
-
-	GLint compileStatus;
-	glGetShaderiv(result, GL_COMPILE_STATUS, &compileStatus);
-	if (compileStatus != GL_TRUE)
-	{
-		// Compile failed
-		ERROR_LOG(VIDEO, "Shader compilation failed; see info log");
-
-		// Don't try to use this shader
-		glDeleteShader(result);
-		return false;
-	}
-#endif
-	(void)GL_REPORT_ERROR();
-	ps.glprogid = result;
-	return true;
-}
-
 void SetPSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1)
 {
 	ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram();
@@ -175,11 +44,11 @@ void SetPSConstant4fvByName(const char * name, unsigned int offset, const float
 	{
 		if (!strcmp(name, UniformNames[a]))
 		{
-			if (tmp.UniformLocations[a] == -1)
+			if (tmp.shader.UniformLocations[a] == -1)
 				return;
 			else
 			{
-				glUniform4fv(tmp.UniformLocations[a] + offset, count, f);
+				glUniform4fv(tmp.shader.UniformLocations[a] + offset, count, f);
 				return;
 			}
 		}
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h
deleted file mode 100644
index a3b85c3fcc..0000000000
--- a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#ifndef _PIXELSHADERCACHE_H_
-#define _PIXELSHADERCACHE_H_
-
-#include <map>
-#include <string>
-
-#include "BPMemory.h"
-#include "PixelShaderGen.h"
-
-namespace OGL
-{
-
-struct FRAGMENTSHADER
-{
-	FRAGMENTSHADER() : glprogid(0) { }
-	void Destroy()
-	{
-		if (glprogid)
-		{
-			glDeleteShader(glprogid);
-			glprogid = 0;
-		}
-	}
-	GLuint glprogid; // opengl program id
-	
-	std::string strprog;
-};
-
-class PixelShaderCache
-{
-	struct PSCacheEntry
-	{
-		FRAGMENTSHADER shader;
-		PSCacheEntry() {}
-		~PSCacheEntry() {}
-		void Destroy()
-		{
-			shader.Destroy();
-		}
-		PIXELSHADERUIDSAFE safe_uid;
-	};
-
-	typedef std::map<PIXELSHADERUID, PSCacheEntry> PSCache;
-
-	static PSCache PixelShaders;
-
-	static PIXELSHADERUID s_curuid; // the current pixel shader uid (progressively changed as memory is written)
-
-    static bool s_displayCompileAlert;
-
-	static GLuint CurrentShader;
-	static PSCacheEntry* last_entry;
-	static PIXELSHADERUID last_uid;
-
-	static bool ShaderEnabled;
-
-public:
-	static void Init();
-	static void Shutdown();
-
-	static FRAGMENTSHADER* SetShader(DSTALPHA_MODE dstAlphaMode, u32 components);
-	static bool CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrprogram);
-};
-}  // namespace OGL
-
-#endif // _PIXELSHADERCACHE_H_
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/PostProcessing.cpp b/Source/Plugins/Plugin_VideoOGL/Src/PostProcessing.cpp
index 531af03aa2..c69932a355 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/PostProcessing.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/PostProcessing.cpp
@@ -20,7 +20,7 @@
 #include "VideoConfig.h"
 #include "GLUtil.h"
 #include "PostProcessing.h"
-#include "PixelShaderCache.h"
+#include "ProgramShaderCache.h"
 
 namespace OGL
 {
@@ -29,7 +29,7 @@ namespace PostProcessing
 {
 
 static std::string s_currentShader;
-static FRAGMENTSHADER s_shader;
+static SHADER s_shader;
 
 void Init()
 {
@@ -63,10 +63,10 @@ bool ApplyShader()
 			std::string code;
 			if (File::ReadFileToString(true, s_currentShader.c_str(), code))
 			{
-				if (!PixelShaderCache::CompilePixelShader(s_shader, code.c_str()))
-				{
-					ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", s_currentShader.c_str());
-				}
+				//if (!ProgramShaderCache::CompileShader(s_shader, "#version130\n...", code.c_str()))
+				//{
+				//	ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", s_currentShader.c_str());
+				//}
 			}
 			else 
 			{
@@ -78,7 +78,7 @@ bool ApplyShader()
 	// TODO: Convert PP shaders to GLSL
 	if (s_shader.glprogid != 0)
 	{
-		// SetBothShaders(s_shader, 0);
+		s_shader.Bind();
 		return true;
 	}
 	else
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp
index 5481f26541..fcffa175c6 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp
@@ -18,37 +18,30 @@
 #include "ProgramShaderCache.h"
 #include "MathUtil.h"
 #include "StreamBuffer.h"
+#include "Debugger.h"
+#include "Statistics.h"
 
 namespace OGL
 {
 
 static const u32 UBO_LENGTH = 4*1024*1024;
 
-GLuint ProgramShaderCache::CurrentProgram = 0;
+static GLuint CurrentProgram = 0;
 ProgramShaderCache::PCache ProgramShaderCache::pshaders;
 GLintptr ProgramShaderCache::s_vs_data_offset;
 u8 *ProgramShaderCache::s_ubo_buffer;
 u32 ProgramShaderCache::s_ubo_buffer_size;
 bool ProgramShaderCache::s_ubo_dirty;
 
-LinearDiskCache<u64, u8> g_program_disk_cache;
+LinearDiskCache<SHADERUID, u8> g_program_disk_cache;
 GLenum ProgramFormat;
 
 GLuint ProgramShaderCache::PCacheEntry::prog_format = 0;
 
-u64 ProgramShaderCache::CurrentShaderProgram;
-
 static StreamBuffer *s_buffer;
 
-u64 Create_Pair(u32 key1, u32 key2)
-{
-	return (((u64)key1) << 32) | key2;
-}
-void Get_Pair(u64 key, u32 *key1, u32 *key2)
-{
-	*key1 = (key & 0xFFFFFFFF00000000) >> 32;
-	*key2 = key & 0xFFFFFFFF;
-}
+ProgramShaderCache::PCacheEntry* ProgramShaderCache::last_entry;
+SHADERUID ProgramShaderCache::last_uid;
 
 const char *UniformNames[NUM_UNIFORMS] =
 {
@@ -75,18 +68,21 @@ const char *UniformNames[NUM_UNIFORMS] =
 	I_DEPTHPARAMS,
 };
 
-void ProgramShaderCache::SetProgramVariables(PCacheEntry &entry)
+void SHADER::SetProgramVariables()
 {
+	// glsl shader must be bind to set samplers
+	Bind();
+	
 	// Bind UBO 
 	if (g_ActiveConfig.backend_info.bSupportsGLSLUBO)
 	{
-		GLint PSBlock_id = glGetUniformBlockIndex(entry.prog_id, "PSBlock");
-		GLint VSBlock_id = glGetUniformBlockIndex(entry.prog_id, "VSBlock");
+		GLint PSBlock_id = glGetUniformBlockIndex(glprogid, "PSBlock");
+		GLint VSBlock_id = glGetUniformBlockIndex(glprogid, "VSBlock");
 		
 		if(PSBlock_id != -1)
-			glUniformBlockBinding(entry.prog_id, PSBlock_id, 1);
+			glUniformBlockBinding(glprogid, PSBlock_id, 1);
 		if(VSBlock_id != -1)
-			glUniformBlockBinding(entry.prog_id, VSBlock_id, 2);
+			glUniformBlockBinding(glprogid, VSBlock_id, 2);
 	}
 	
 	// We cache our uniform locations for now
@@ -94,12 +90,12 @@ void ProgramShaderCache::SetProgramVariables(PCacheEntry &entry)
 	// We can remove this
 
 	// (Sonicadvance): For some reason this fails on my hardware
-	//glGetUniformIndices(entry.prog_id, NUM_UNIFORMS, UniformNames, entry.UniformLocations);
+	//glGetUniformIndices(glprogid, NUM_UNIFORMS, UniformNames, UniformLocations);
 	// Got to do it this crappy way.
-	entry.UniformLocations[0] = glGetUniformLocation(entry.prog_id, UniformNames[0]);
+	UniformLocations[0] = glGetUniformLocation(glprogid, UniformNames[0]);
 	if (!g_ActiveConfig.backend_info.bSupportsGLSLUBO)
 		for (int a = 1; a < NUM_UNIFORMS; ++a)
-			entry.UniformLocations[a] = glGetUniformLocation(entry.prog_id, UniformNames[a]);
+			UniformLocations[a] = glGetUniformLocation(glprogid, UniformNames[a]);
 
 	// Bind Texture Sampler
 	for (int a = 0; a <= 9; ++a)
@@ -108,165 +104,284 @@ void ProgramShaderCache::SetProgramVariables(PCacheEntry &entry)
 		snprintf(name, 8, "samp%d", a);
 		
 		// Still need to get sampler locations since we aren't binding them statically in the shaders
-		int loc = glGetUniformLocation(entry.prog_id, name);
+		int loc = glGetUniformLocation(glprogid, name);
 		if (loc != -1)
 			glUniform1i(loc, a);
 	}
 
 }
 
-void ProgramShaderCache::SetProgramBindings ( ProgramShaderCache::PCacheEntry& entry )
+void SHADER::SetProgramBindings()
 {
 	if (g_ActiveConfig.backend_info.bSupportsDualSourceBlend)
 	{
 		// So we do support extended blending
 		// So we need to set a few more things here.
 		// Bind our out locations
-		glBindFragDataLocationIndexed(entry.prog_id, 0, 0, "ocol0");
-		glBindFragDataLocationIndexed(entry.prog_id, 0, 1, "ocol1");
+		glBindFragDataLocationIndexed(glprogid, 0, 0, "ocol0");
+		glBindFragDataLocationIndexed(glprogid, 0, 1, "ocol1");
 	}
 	else
-		glBindFragDataLocation(entry.prog_id, 0, "ocol0");
+		glBindFragDataLocation(glprogid, 0, "ocol0");
 
 	// Need to set some attribute locations
-	glBindAttribLocation(entry.prog_id, SHADER_POSITION_ATTRIB, "rawpos");
+	glBindAttribLocation(glprogid, SHADER_POSITION_ATTRIB, "rawpos");
 	
-	glBindAttribLocation(entry.prog_id, SHADER_POSMTX_ATTRIB,   "fposmtx");
+	glBindAttribLocation(glprogid, SHADER_POSMTX_ATTRIB,   "fposmtx");
 	
-	glBindAttribLocation(entry.prog_id, SHADER_COLOR0_ATTRIB,   "color0");
-	glBindAttribLocation(entry.prog_id, SHADER_COLOR1_ATTRIB,   "color1");
+	glBindAttribLocation(glprogid, SHADER_COLOR0_ATTRIB,   "color0");
+	glBindAttribLocation(glprogid, SHADER_COLOR1_ATTRIB,   "color1");
 	
-	glBindAttribLocation(entry.prog_id, SHADER_NORM0_ATTRIB,    "rawnorm0");
-	glBindAttribLocation(entry.prog_id, SHADER_NORM1_ATTRIB,    "rawnorm1");
-	glBindAttribLocation(entry.prog_id, SHADER_NORM2_ATTRIB,    "rawnorm2");
+	glBindAttribLocation(glprogid, SHADER_NORM0_ATTRIB,    "rawnorm0");
+	glBindAttribLocation(glprogid, SHADER_NORM1_ATTRIB,    "rawnorm1");
+	glBindAttribLocation(glprogid, SHADER_NORM2_ATTRIB,    "rawnorm2");
 	
 	for(int i=0; i<8; i++) {
 		char attrib_name[8];
 		snprintf(attrib_name, 8, "tex%d", i);
-		glBindAttribLocation(entry.prog_id, SHADER_TEXTURE0_ATTRIB+i, attrib_name);
+		glBindAttribLocation(glprogid, SHADER_TEXTURE0_ATTRIB+i, attrib_name);
 	}
 }
 
+void SHADER::Bind()
+{
+	if(CurrentProgram != glprogid)
+	{
+		glUseProgram(glprogid);
+		CurrentProgram = glprogid;
+	}
+}
+
+
+void ProgramShaderCache::SetMultiPSConstant4fv(unsigned int offset, const float *f, unsigned int count)
+{
+	s_ubo_dirty = true;
+	memcpy(s_ubo_buffer+(offset*4*sizeof(float)), f, count*4*sizeof(float));
+}
+
+void ProgramShaderCache::SetMultiVSConstant4fv(unsigned int offset, const float *f, unsigned int count)
+{
+	s_ubo_dirty = true;
+	memcpy(s_ubo_buffer+(offset*4*sizeof(float))+s_vs_data_offset, f, count*4*sizeof(float));
+}
 
-void ProgramShaderCache::SetBothShaders(GLuint PS, GLuint VS)
+void ProgramShaderCache::UploadConstants()
 {
-	if(!PS || !VS) {
-		ERROR_LOG(VIDEO, "tried to bind a zero shader");
-		return;
+	if(s_ubo_dirty) {
+		s_buffer->Alloc(s_ubo_buffer_size);
+		size_t offset = s_buffer->Upload(s_ubo_buffer, s_ubo_buffer_size);
+		glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->getBuffer(), offset, s_vs_data_offset);
+		glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->getBuffer(), offset + s_vs_data_offset, s_ubo_buffer_size - s_vs_data_offset);
+		s_ubo_dirty = false;
 	}
+}
+
+GLuint ProgramShaderCache::GetCurrentProgram(void)
+{
+	return CurrentProgram;
+}
+
+SHADER* ProgramShaderCache::SetShader ( DSTALPHA_MODE dstAlphaMode, u32 components )
+{
+	SHADERUID uid;
+	GetShaderId(&uid, dstAlphaMode, components);
 	
-	u64 ShaderPair = Create_Pair(PS, VS);
+	// Check if the shader is already set
+	if (last_entry)
+	{
+		if (uid == last_uid)
+		{
+			GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
+			ValidateShaderIDs(last_entry, dstAlphaMode, components);
+			last_entry->shader.Bind();
+			return &last_entry->shader;
+		}
+	}
 	
-	// program is already bound
-	if(ShaderPair == CurrentShaderProgram) return;
+	last_uid = uid;
 	
-	PCache::iterator iter = pshaders.find(ShaderPair);
+	// Check if shader is already in cache
+	PCache::iterator iter = pshaders.find(uid);
 	if (iter != pshaders.end())
 	{
-		PCacheEntry &entry = iter->second;
-		glUseProgram(entry.prog_id);
-		CurrentProgram = entry.prog_id;
-		CurrentShaderProgram = ShaderPair;
-		return;
+		PCacheEntry *entry = &iter->second;
+		last_entry = entry;
+
+		GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
+		ValidateShaderIDs(entry, dstAlphaMode, components);
+		last_entry->shader.Bind();
+		return &last_entry->shader;
+	}
+	
+	// Make an entry in the table
+	PCacheEntry& newentry = pshaders[uid];
+	last_entry = &newentry;
+	
+	const char *vcode = GenerateVertexShaderCode(components, API_OPENGL);
+	const char *pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components);
+	
+	if (g_ActiveConfig.bEnableShaderDebugging)
+	{
+		GetSafePixelShaderId(&newentry.safe_uid, dstAlphaMode, components);
+		newentry.shader.strvprog = vcode;
+		newentry.shader.strpprog = pcode;
 	}
 
-	PCacheEntry entry;
-	entry.Create(PS, VS);
+#if defined(_DEBUG) || defined(DEBUGFAST)
+	if (g_ActiveConfig.iLog & CONF_SAVESHADERS) {
+		static int counter = 0;
+		char szTemp[MAX_PATH];
+		sprintf(szTemp, "%svs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
+		SaveData(szTemp, vcode);
+		sprintf(szTemp, "%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
+		SaveData(szTemp, pcode);
+	}
+#endif
 
-	// Right, the program is created now
-	// Let's attach everything
-	glAttachShader(entry.prog_id, entry.vsid);
-	glAttachShader(entry.prog_id, entry.psid);
+	if (!CompileShader(newentry.shader, vcode, pcode)) {
+		GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
+		return NULL;
+	}
+
+	INCSTAT(stats.numPixelShadersCreated);
+	SETSTAT(stats.numPixelShadersAlive, pshaders.size());
+	GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
+	
+	last_entry->shader.Bind();
+	return &last_entry->shader;
+}
+
+bool ProgramShaderCache::CompileShader ( SHADER& shader, const char* vcode, const char* pcode )
+{
+	GLuint vsid = CompileSingleShader(GL_VERTEX_SHADER, vcode);
+	GLuint psid = CompileSingleShader(GL_FRAGMENT_SHADER, pcode);
+	
+	if(!vsid || !psid)
+	{
+		glDeleteShader(vsid);
+		glDeleteShader(psid);
+		return false;
+	}
+	
+	GLuint pid = shader.glprogid = glCreateProgram();;
+	
+	glAttachShader(pid, vsid);
+	glAttachShader(pid, psid);
 
 	if (g_ActiveConfig.backend_info.bSupportsGLSLCache)
-		glProgramParameteri(entry.prog_id, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+		glProgramParameteri(pid, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
 
-	SetProgramBindings(entry);
+	shader.SetProgramBindings();
 	
-	glLinkProgram(entry.prog_id);
+	glLinkProgram(pid);
+	
+	// original shaders aren't needed any more
+	glDeleteShader(vsid);
+	glDeleteShader(psid);
 	
 #if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
 	GLsizei length = 0;
-	glGetProgramiv(entry.prog_id, GL_INFO_LOG_LENGTH, &length);
+	glGetProgramiv(pid, GL_INFO_LOG_LENGTH, &length);
 	if (length > 1)
 	{
 		GLsizei charsWritten;
 		GLchar* infoLog = new GLchar[length];
-		glGetProgramInfoLog(entry.prog_id, length, &charsWritten, infoLog);
+		glGetProgramInfoLog(pid, length, &charsWritten, infoLog);
 		ERROR_LOG(VIDEO, "Program info log:\n%s", infoLog);
 		char szTemp[MAX_PATH];
-		sprintf(szTemp, "p_%d.txt", entry.prog_id);
+		sprintf(szTemp, "p_%d.txt", pid);
 		FILE *fp = fopen(szTemp, "wb");
 		fwrite(infoLog, length, 1, fp);
 		delete[] infoLog;
-		
-		glGetShaderiv(VS, GL_SHADER_SOURCE_LENGTH, &length);
-		GLchar* src = new GLchar[length];
-		glGetShaderSource(VS, length, &charsWritten, src);
-		fwrite(src, strlen(src), 1, fp);
-		delete [] src;
-		
-		glGetShaderiv(PS, GL_SHADER_SOURCE_LENGTH, &length);
-		src = new GLchar[length];
-		glGetShaderSource(PS, length, &charsWritten, src);
-		fwrite(src, strlen(src), 1, fp);
-		delete [] src;
+		fwrite(vcode, strlen(vcode), 1, fp);
+		fwrite(pcode, strlen(pcode), 1, fp);
 		fclose(fp);
 	}
 
 	GLint linkStatus;
-	glGetProgramiv(entry.prog_id, GL_LINK_STATUS, &linkStatus);
+	glGetProgramiv(pid, GL_LINK_STATUS, &linkStatus);
 	if (linkStatus != GL_TRUE)
 	{
 		// Compile failed
 		ERROR_LOG(VIDEO, "Program linking failed; see info log");
 
 		// Don't try to use this shader
-		glDeleteProgram(entry.prog_id);
-		return;
+		glDeleteProgram(pid);
+		return false;
 	}
 #endif
 
-	glUseProgram(entry.prog_id);
-
-	SetProgramVariables(entry);
-
-	pshaders[ShaderPair] = entry;
-	CurrentShaderProgram = ShaderPair;
-	CurrentProgram = entry.prog_id;
+	shader.SetProgramVariables();
+	
+	return true;
 }
 
-void ProgramShaderCache::SetMultiPSConstant4fv(unsigned int offset, const float *f, unsigned int count)
+GLuint ProgramShaderCache::CompileSingleShader (GLuint type, const char* code )
 {
-	s_ubo_dirty = true;
-	memcpy(s_ubo_buffer+(offset*4*sizeof(float)), f, count*4*sizeof(float));
+	GLuint result = glCreateShader(type);
+
+	const char *src[] = {code};
+	
+	glShaderSource(result, 1, src, NULL);
+	glCompileShader(result);
+#if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
+	GLsizei length = 0;
+	glGetShaderiv(result, GL_INFO_LOG_LENGTH, &length);
+	if (length > 1)
+	{
+		GLsizei charsWritten;
+		GLchar* infoLog = new GLchar[length];
+		glGetShaderInfoLog(result, length, &charsWritten, infoLog);
+		ERROR_LOG(VIDEO, "PS Shader info log:\n%s", infoLog);
+		char szTemp[MAX_PATH];
+		sprintf(szTemp, "ps_%d.txt", result);
+		FILE *fp = fopen(szTemp, "wb");
+		fwrite(infoLog, strlen(infoLog), 1, fp);
+		fwrite(code, strlen(code), 1, fp);
+		fclose(fp);
+		delete[] infoLog;
+	}
+
+	GLint compileStatus;
+	glGetShaderiv(result, GL_COMPILE_STATUS, &compileStatus);
+	if (compileStatus != GL_TRUE)
+	{
+		// Compile failed
+		ERROR_LOG(VIDEO, "Shader compilation failed; see info log");
+
+		// Don't try to use this shader
+		glDeleteShader(result);
+		return 0;
+	}
+#endif
+	(void)GL_REPORT_ERROR();
+	return result;
 }
 
-void ProgramShaderCache::SetMultiVSConstant4fv(unsigned int offset, const float *f, unsigned int count)
+
+
+void ProgramShaderCache::GetShaderId ( SHADERUID* uid, DSTALPHA_MODE dstAlphaMode, u32 components )
 {
-	s_ubo_dirty = true;
-	memcpy(s_ubo_buffer+(offset*4*sizeof(float))+s_vs_data_offset, f, count*4*sizeof(float));
+	GetPixelShaderId(&uid->puid, dstAlphaMode, components);
+	GetVertexShaderId(&uid->vuid, components);
 }
 
-void ProgramShaderCache::UploadConstants()
+void ProgramShaderCache::GetSafeShaderId ( SHADERUIDSAFE* uid, DSTALPHA_MODE dstAlphaMode, u32 components )
 {
-	if(s_ubo_dirty) {
-		s_buffer->Alloc(s_ubo_buffer_size);
-		size_t offset = s_buffer->Upload(s_ubo_buffer, s_ubo_buffer_size);
-		glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->getBuffer(), offset, s_vs_data_offset);
-		glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->getBuffer(), offset + s_vs_data_offset, s_ubo_buffer_size - s_vs_data_offset);
-		s_ubo_dirty = false;
-	}
+	GetSafePixelShaderId(&uid->puid, dstAlphaMode, components);
+	GetSafeVertexShaderId(&uid->vuid, components);
 }
 
-GLuint ProgramShaderCache::GetCurrentProgram(void)
+void ProgramShaderCache::ValidateShaderIDs ( PCacheEntry *entry, DSTALPHA_MODE dstAlphaMode, u32 components )
 {
-	return CurrentProgram;
+	//ValidatePixelShaderIDs(API_OPENGL, entry->safe_uid, entry->shader.strprog, dstAlphaMode, components);
 }
 
+
+
 ProgramShaderCache::PCacheEntry ProgramShaderCache::GetShaderProgram(void)
 {
-	return pshaders[CurrentShaderProgram];
+	return *last_entry;
 }
 
 void ProgramShaderCache::Init(void)
@@ -308,7 +423,7 @@ void ProgramShaderCache::Init(void)
 	}
 	
 	CurrentProgram = 0;
-	CurrentShaderProgram = 0;
+	last_entry = NULL;
 }
 
 void ProgramShaderCache::Shutdown(void)
@@ -318,7 +433,7 @@ void ProgramShaderCache::Shutdown(void)
 		PCache::iterator iter = pshaders.begin();
 		for (; iter != pshaders.end(); ++iter)
 		{
-			g_program_disk_cache.Append(iter->second.uid, iter->second.GetProgram(), iter->second.Size());
+			g_program_disk_cache.Append(iter->first, iter->second.GetProgram(), iter->second.Size());
 			iter->second.FreeProgram();
 		}
 
@@ -342,4 +457,23 @@ void ProgramShaderCache::Shutdown(void)
 	}
 }
 
+void ProgramShaderCache::ProgramShaderCacheInserter::Read ( const SHADERUID& key, const u8* value, u32 value_size )
+{
+	// The two shaders might not even exist anymore
+	// But it is fine, no need to worry about that
+	PCacheEntry entry;
+	entry.shader.glprogid = glCreateProgram();
+	glProgramBinary(entry.shader.glprogid, entry.prog_format, value, value_size);
+
+	GLint success;
+	glGetProgramiv(entry.shader.glprogid, GL_LINK_STATUS, &success);
+
+	if (success)
+	{
+		pshaders[key] = entry;
+		entry.shader.SetProgramVariables();
+	}
+}
+
+
 } // namespace OGL
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h
index a173b23095..76df0787e8 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h
+++ b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h
@@ -20,28 +20,63 @@
 
 #include "GLUtil.h"
 
-#include "VertexShaderCache.h"
-#include "PixelShaderCache.h"
 #include "PixelShaderGen.h"
 #include "VertexShaderGen.h"
 
 #include "LinearDiskCache.h"
 #include "ConfigManager.h"
 
-#ifdef __APPLE__
-#include <tr1/unordered_map>
-using namespace std::tr1;
-#else
-#include <unordered_map>
-using namespace std;
-#endif
 namespace OGL
 {
 
+template<bool safe>
+class _SHADERUID
+{
+public:
+	_VERTEXSHADERUID<safe> vuid;
+	_PIXELSHADERUID<safe> puid;
+
+	_SHADERUID() {}
+
+	_SHADERUID(const _SHADERUID& r) : vuid(r.vuid), puid(r.puid) {}
+
+	bool operator <(const _SHADERUID& r) const
+	{
+		if(puid < r.puid) return true;
+		if(r.puid < puid) return false;
+		if(vuid < r.vuid) return true;
+		return false;
+	}
+
+	bool operator ==(const _SHADERUID& r) const
+	{
+		return puid == r.puid && vuid == r.vuid;
+	}
+};
+typedef _SHADERUID<false> SHADERUID;
+typedef _SHADERUID<true> SHADERUIDSAFE;
+
+
 const int NUM_UNIFORMS = 19;
 extern const char *UniformNames[NUM_UNIFORMS];
-u64 Create_Pair(u32 key1, u32 key2);
-void Get_Pair(u64 key, u32 *key1, u32 *key2);
+
+struct SHADER
+{
+	SHADER() : glprogid(0) { }
+	void Destroy()
+	{
+		glDeleteProgram(glprogid);
+		glprogid = 0;
+	}
+	GLuint glprogid; // opengl program id
+	
+	std::string strvprog, strpprog;
+	GLint UniformLocations[NUM_UNIFORMS];
+	
+	void SetProgramVariables();
+	void SetProgramBindings();
+	void Bind();
+};
 
 class ProgramShaderCache
 {
@@ -49,39 +84,27 @@ public:
 
 	struct PCacheEntry
 	{
-		GLuint prog_id;
+		SHADER shader;
+		PIXELSHADERUIDSAFE safe_uid;
+		
 		static GLenum prog_format;
 		u8 *binary;
 		GLint binary_size;
-		GLuint vsid, psid;
-		u64 uid;
-		GLint UniformLocations[NUM_UNIFORMS];
-
-		PCacheEntry() : prog_id(0), binary(NULL), binary_size(0), vsid(0), psid(0)  { }
+		
+		PCacheEntry() :binary(NULL), binary_size(0) { }
 
-		~PCacheEntry()
-		{
-			FreeProgram();
-		}
-
-		void Create(const GLuint pix_id, const GLuint vert_id)
-		{
-			psid = pix_id;
-			vsid = vert_id;
-			uid = Create_Pair(psid, vsid);
-			prog_id = glCreateProgram();
-		}
+		~PCacheEntry() {}
 
 		void Destroy()
 		{
-			glDeleteProgram(prog_id);
-			prog_id = 0;
+			shader.Destroy();
+			FreeProgram();
 		}
 
 		void UpdateSize()
 		{
 			if (binary_size == 0)
-				glGetProgramiv(prog_id, GL_PROGRAM_BINARY_LENGTH, &binary_size);
+				glGetProgramiv(shader.glprogid, GL_PROGRAM_BINARY_LENGTH, &binary_size);
 		}
 
 		// No idea how necessary this is
@@ -103,7 +126,7 @@ public:
 			UpdateSize();
 			FreeProgram();
 			binary = new u8[binary_size];
-			glGetProgramBinary(prog_id, binary_size, NULL, &prog_format, binary);
+			glGetProgramBinary(shader.glprogid, binary_size, NULL, &prog_format, binary);
 			return binary;
 		}
 
@@ -121,8 +144,14 @@ public:
 	};
 
 	static PCacheEntry GetShaderProgram(void);
-	static void SetBothShaders(GLuint PS, GLuint VS);
 	static GLuint GetCurrentProgram(void);
+	static SHADER* SetShader(DSTALPHA_MODE dstAlphaMode, u32 components);
+	static void GetShaderId(SHADERUID *uid, DSTALPHA_MODE dstAlphaMode, u32 components);
+	static void GetSafeShaderId(SHADERUIDSAFE *uid, DSTALPHA_MODE dstAlphaMode, u32 components);
+	static void ValidateShaderIDs(PCacheEntry *entry, DSTALPHA_MODE dstAlphaMode, u32 components);
+	
+	static bool CompileShader(SHADER &shader, const char* vcode, const char* pcode);
+	static GLuint CompileSingleShader(GLuint type, const char *code);
 
 	static void SetMultiPSConstant4fv(unsigned int offset, const float *f, unsigned int count);
 	static void SetMultiVSConstant4fv(unsigned int offset, const float *f, unsigned int count);
@@ -132,44 +161,22 @@ public:
 	static void Shutdown(void);
 
 private:
-	class ProgramShaderCacheInserter : public LinearDiskCacheReader<u64, u8>
+	class ProgramShaderCacheInserter : public LinearDiskCacheReader<SHADERUID, u8>
 	{
 	public:
-		void Read(const u64 &key, const u8 *value, u32 value_size)
-		{
-			// The two shaders might not even exist anymore
-			// But it is fine, no need to worry about that
-			PCacheEntry entry;
-			u32 key1, key2;
-			Get_Pair(key, &key1, &key2);
-			entry.Create(key1, key2);
-
-			glProgramBinary(entry.prog_id, entry.prog_format, value, value_size);
-
-			GLint success;
-			glGetProgramiv(entry.prog_id, GL_LINK_STATUS, &success);
-
-			if (success)
-			{
-				pshaders[key] = entry;
-				glUseProgram(entry.prog_id);
-				SetProgramVariables(entry);
-			}
-		}
+		void Read(const SHADERUID &key, const u8 *value, u32 value_size);
 	};
 
-	typedef unordered_map<u64, PCacheEntry> PCache;
+	typedef std::map<SHADERUID, PCacheEntry> PCache;
 
 	static PCache pshaders;
-	static GLuint CurrentProgram;
-	static u64 CurrentShaderProgram;
+	static PCacheEntry* last_entry;
+	static SHADERUID last_uid;
 
 	static GLintptr s_vs_data_offset;
 	static u8 *s_ubo_buffer;
 	static u32 s_ubo_buffer_size;
 	static bool s_ubo_dirty;
-	static void SetProgramVariables(PCacheEntry &entry);
-	static void SetProgramBindings(PCacheEntry &entry);
 };
 
 }  // namespace OGL
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/RasterFont.cpp b/Source/Plugins/Plugin_VideoOGL/Src/RasterFont.cpp
index f7afb63c9c..19e36b0774 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/RasterFont.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/RasterFont.cpp
@@ -18,9 +18,7 @@
 #include "GLUtil.h"
 
 #include "RasterFont.h"
-#include "PixelShaderCache.h"
 #include "ProgramShaderCache.h"
-#include "VertexShaderCache.h"
 // globals
 
 namespace OGL {
@@ -149,9 +147,7 @@ static const char *s_fragmentShaderSrc =
 	"	ocol0 = texture(samp8,uv0) * color;\n"
 	"}\n";
 	
-	
-static FRAGMENTSHADER s_fragmentShader;
-static VERTEXSHADER s_vertexShader;
+static SHADER s_shader;
 	
 RasterFont::RasterFont()
 {
@@ -174,14 +170,11 @@ RasterFont::RasterFont()
 	delete [] texture_data;
 	
 	// generate shader
-	VertexShaderCache::CompileVertexShader(s_vertexShader, s_vertexShaderSrc);
-	PixelShaderCache::CompilePixelShader(s_fragmentShader, s_fragmentShaderSrc);
-	ProgramShaderCache::SetBothShaders(s_fragmentShader.glprogid, s_vertexShader.glprogid);
-	GLuint shader_program = ProgramShaderCache::GetCurrentProgram();
+	ProgramShaderCache::CompileShader(s_shader, s_vertexShaderSrc, s_fragmentShaderSrc);
 	
 	// bound uniforms
-	glUniform2f(glGetUniformLocation(shader_program,"charSize"), 1.0f / GLfloat(char_count), 1.0f);
-	uniform_color_id = glGetUniformLocation(shader_program,"color");
+	glUniform2f(glGetUniformLocation(s_shader.glprogid,"charSize"), 1.0f / GLfloat(char_count), 1.0f);
+	uniform_color_id = glGetUniformLocation(s_shader.glprogid,"color");
 	glUniform4f(uniform_color_id, 1.0f, 1.0f, 1.0f, 1.0f);
 	cached_color = -1;
 	
@@ -201,8 +194,7 @@ RasterFont::~RasterFont()
 	glDeleteTextures(1, &texture);
 	glDeleteBuffers(1, &VBO);
 	glDeleteVertexArrays(1, &VAO);
-	s_fragmentShader.Destroy();
-	s_vertexShader.Destroy();
+	s_shader.Destroy();
 }
 
 void RasterFont::printMultilineText(const char *text, double start_x, double start_y, double z, int bbWidth, int bbHeight, u32 color)
@@ -280,7 +272,7 @@ void RasterFont::printMultilineText(const char *text, double start_x, double sta
 	
 	delete [] vertices;
 
-	ProgramShaderCache::SetBothShaders(s_fragmentShader.glprogid, s_vertexShader.glprogid);
+	s_shader.Bind();
 	
 	if(color != cached_color) {
 		glUniform4f(uniform_color_id, GLfloat((color>>16)&0xff)/255.f,GLfloat((color>>8)&0xff)/255.f,GLfloat((color>>0)&0xff)/255.f,GLfloat((color>>24)&0xff)/255.f);
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp b/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp
index d1abe7ffe2..f311cc62ad 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp
@@ -43,10 +43,8 @@
 #include "RasterFont.h"
 #include "VertexShaderGen.h"
 #include "DLCache.h"
-#include "PixelShaderCache.h"
 #include "PixelShaderManager.h"
 #include "ProgramShaderCache.h"
-#include "VertexShaderCache.h"
 #include "VertexShaderManager.h"
 #include "VertexLoaderManager.h"
 #include "VertexLoader.h"
@@ -107,8 +105,7 @@ namespace OGL
 static int s_fps = 0;
 static GLuint s_ShowEFBCopyRegions_VBO = 0;
 static GLuint s_ShowEFBCopyRegions_VAO = 0;
-static FRAGMENTSHADER s_ShowEFBCopyRegions_PS;
-static VERTEXSHADER s_ShowEFBCopyRegions_VS;
+static SHADER s_ShowEFBCopyRegions;
 
 static RasterFont* s_pfont = NULL;
 
@@ -433,23 +430,14 @@ void Renderer::Shutdown()
 	
 	delete s_pfont;
 	s_pfont = 0;
-	s_ShowEFBCopyRegions_PS.Destroy();
-	s_ShowEFBCopyRegions_VS.Destroy();
+	s_ShowEFBCopyRegions.Destroy();
 }
 
 void Renderer::Init()
 {
 	s_pfont = new RasterFont();
 	
-	PixelShaderCache::CompilePixelShader(s_ShowEFBCopyRegions_PS,
-		"#version 130\n"
-		"in vec4 c;\n"
-		"out vec4 ocol0;\n"
-		"void main(void) {\n"
-		"	ocol0 = c;\n"
-		"}\n"
-	);
-	VertexShaderCache::CompileVertexShader(s_ShowEFBCopyRegions_VS,
+	ProgramShaderCache::CompileShader(s_ShowEFBCopyRegions, 
 		"#version 130\n"
 		"in vec2 rawpos;\n"
 		"in vec3 color0;\n"
@@ -457,8 +445,13 @@ void Renderer::Init()
 		"void main(void) {\n"
 		"	gl_Position = vec4(rawpos,0,1);\n"
 		"	c = vec4(color0, 1.0);\n"
-		"}\n"
-	);
+		"}\n",
+		"#version 130\n"
+		"in vec4 c;\n"
+		"out vec4 ocol0;\n"
+		"void main(void) {\n"
+		"	ocol0 = c;\n"
+		"}\n");
 	
 	// creating buffers
 	glGenBuffers(1, &s_ShowEFBCopyRegions_VBO);
@@ -603,7 +596,7 @@ void Renderer::DrawDebugInfo()
 		}
 		glUnmapBuffer(GL_ARRAY_BUFFER);
 		
-		ProgramShaderCache::SetBothShaders(s_ShowEFBCopyRegions_PS.glprogid, s_ShowEFBCopyRegions_VS.glprogid);
+		s_ShowEFBCopyRegions.Bind();
 		glBindVertexArray( s_ShowEFBCopyRegions_VAO );
 		glDrawArrays(GL_LINES, 0, stats.efb_regions.size() * 2*6);
 
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/TextureCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/TextureCache.cpp
index ae25c33a57..0aa47430dc 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/TextureCache.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/TextureCache.cpp
@@ -42,7 +42,6 @@
 #include "HW/Memmap.h"
 #include "ImageWrite.h"
 #include "MemoryUtil.h"
-#include "PixelShaderCache.h"
 #include "ProgramShaderCache.h"
 #include "PixelShaderManager.h"
 #include "Render.h"
@@ -57,13 +56,12 @@
 namespace OGL
 {
 
-static FRAGMENTSHADER s_ColorMatrixProgram;
-static FRAGMENTSHADER s_DepthMatrixProgram;
+static SHADER s_ColorMatrixProgram;
+static SHADER s_DepthMatrixProgram;
 static GLuint s_ColorMatrixUniform;
 static GLuint s_DepthMatrixUniform;
 static u32 s_ColorCbufid;
 static u32 s_DepthCbufid;
-static VERTEXSHADER s_vProgram;
 
 static u32 s_Textures[8];
 static u32 s_ActiveTexture;
@@ -335,12 +333,12 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 		glViewport(0, 0, virtual_width, virtual_height);
 
 		if(srcFormat == PIXELFMT_Z24) {
-			ProgramShaderCache::SetBothShaders(s_DepthMatrixProgram.glprogid, s_vProgram.glprogid);
+			s_DepthMatrixProgram.Bind();
 			if(s_DepthCbufid != cbufid)
 				glUniform4fv(s_DepthMatrixUniform, 5, colmat);
 			s_DepthCbufid = cbufid;
 		} else {
-			ProgramShaderCache::SetBothShaders(s_ColorMatrixProgram.glprogid, s_vProgram.glprogid);
+			s_ColorMatrixProgram.Bind();
 			if(s_ColorCbufid != cbufid)
 				glUniform4fv(s_ColorMatrixUniform, 7, colmat);
 			s_ColorCbufid = cbufid;
@@ -499,11 +497,6 @@ TextureCache::TextureCache()
 		"	Temp1.w = dot(Temp0, colmat[3]);\n"
 		"	ocol0 = Temp1 + colmat[4];\n"
 		"}\n";
-	if (!PixelShaderCache::CompilePixelShader(s_ColorMatrixProgram, pColorMatrixProg))
-	{
-		ERROR_LOG(VIDEO, "Failed to create color matrix fragment program");
-		s_ColorMatrixProgram.Destroy();
-	}
 
 	const char *pDepthMatrixProg =
 		"#version 130\n"
@@ -538,11 +531,6 @@ TextureCache::TextureCache()
 		"	ocol0 = R1 * colmat[4];\n"
 		"}\n";
 
-	if (!PixelShaderCache::CompilePixelShader(s_DepthMatrixProgram, pDepthMatrixProg))
-	{
-		ERROR_LOG(VIDEO, "Failed to create depth matrix fragment program");
-		s_DepthMatrixProgram.Destroy();
-	}
 	
 	const char *VProgram =
 		"#version 130\n"
@@ -554,13 +542,12 @@ TextureCache::TextureCache()
 		"	uv0 = tex0;\n"
 		"	gl_Position = vec4(rawpos,0,1);\n"
 		"}\n";
-	if (!VertexShaderCache::CompileVertexShader(s_vProgram, VProgram))
-		ERROR_LOG(VIDEO, "Failed to create texture converter vertex program.");
+		
+	ProgramShaderCache::CompileShader(s_ColorMatrixProgram, VProgram, pColorMatrixProg);
+	ProgramShaderCache::CompileShader(s_DepthMatrixProgram, VProgram, pDepthMatrixProg);
 	
-	ProgramShaderCache::SetBothShaders(s_ColorMatrixProgram.glprogid, s_vProgram.glprogid);
-	s_ColorMatrixUniform = glGetUniformLocation(ProgramShaderCache::GetCurrentProgram(), "colmat");
-	ProgramShaderCache::SetBothShaders(s_DepthMatrixProgram.glprogid, s_vProgram.glprogid);
-	s_DepthMatrixUniform = glGetUniformLocation(ProgramShaderCache::GetCurrentProgram(), "colmat");
+	s_ColorMatrixUniform = glGetUniformLocation(s_ColorMatrixProgram.glprogid, "colmat");
+	s_DepthMatrixUniform = glGetUniformLocation(s_DepthMatrixProgram.glprogid, "colmat");
 	s_ColorCbufid = -1;
 	s_DepthCbufid = -1;
 	
@@ -574,7 +561,6 @@ TextureCache::~TextureCache()
 {
 	s_ColorMatrixProgram.Destroy();
 	s_DepthMatrixProgram.Destroy();
-	s_vProgram.Destroy();
 	
 	for(std::map<u64, VBOCache>::iterator it = s_VBO.begin(); it != s_VBO.end(); it++) {
 		glDeleteBuffers(1, &it->second.vbo);
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/TextureConverter.cpp b/Source/Plugins/Plugin_VideoOGL/Src/TextureConverter.cpp
index 1dad409a64..6914f00379 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/TextureConverter.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/TextureConverter.cpp
@@ -23,7 +23,6 @@
 #include "TextureConverter.h"
 #include "TextureConversionShader.h"
 #include "TextureCache.h"
-#include "PixelShaderCache.h"
 #include "ProgramShaderCache.h"
 #include "VertexShaderManager.h"
 #include "FramebufferManager.h"
@@ -51,13 +50,12 @@ static GLuint s_dstRenderBuffer = 0;	// for encoding to RAM
 const int renderBufferWidth = 1024;
 const int renderBufferHeight = 1024;
 
-static FRAGMENTSHADER s_rgbToYuyvProgram;
-static FRAGMENTSHADER s_yuyvToRgbProgram;
-static VERTEXSHADER s_vProgram;
+static SHADER s_rgbToYuyvProgram;
+static SHADER s_yuyvToRgbProgram;
 
 // Not all slots are taken - but who cares.
 const u32 NUM_ENCODING_PROGRAMS = 64;
-static FRAGMENTSHADER s_encodingPrograms[NUM_ENCODING_PROGRAMS];
+static SHADER s_encodingPrograms[NUM_ENCODING_PROGRAMS];
 
 static GLuint s_encode_VBO = 0;
 static GLuint s_encode_VAO = 0;
@@ -67,6 +65,17 @@ static TargetRectangle s_cached_sourceRc;
 static int s_cached_srcWidth = 0;
 static int s_cached_srcHeight = 0;
 
+static const char *VProgram =
+	"#version 130\n"
+	"in vec2 rawpos;\n"
+	"in vec2 tex0;\n"
+	"out vec2 uv0;\n"
+	"void main()\n"
+	"{\n"
+	"	uv0 = tex0;\n"
+	"	gl_Position = vec4(rawpos,0,1);\n"
+	"}\n";
+
 void CreatePrograms()
 {
 	// Output is BGRA because that is slightly faster than RGBA.
@@ -87,8 +96,6 @@ void CreatePrograms()
 		"	vec4 const3 = vec4(0.0625,0.5,0.0625f,0.5);\n"
 		"	ocol0 = vec4(dot(c1,y_const),dot(c01,u_const),dot(c0,y_const),dot(c01, v_const)) + const3;\n"
 		"}\n";
-	if (!PixelShaderCache::CompilePixelShader(s_rgbToYuyvProgram, FProgramRgbToYuyv))
-		ERROR_LOG(VIDEO, "Failed to create RGB to YUYV fragment program.");
 
 	const char *FProgramYuyvToRgb =
 		"#version 130\n"
@@ -109,24 +116,12 @@ void CreatePrograms()
 		"		yComp + (2.018f * uComp),\n"
 		"		1.0f);\n"
 		"}\n";
-	if (!PixelShaderCache::CompilePixelShader(s_yuyvToRgbProgram, FProgramYuyvToRgb))
-		ERROR_LOG(VIDEO, "Failed to create YUYV to RGB fragment program.");
-	
-	const char *VProgram =
-		"#version 130\n"
-		"in vec2 rawpos;\n"
-		"in vec2 tex0;\n"
-		"out vec2 uv0;\n"
-		"void main()\n"
-		"{\n"
-		"	uv0 = tex0;\n"
-		"	gl_Position = vec4(rawpos,0,1);\n"
-		"}\n";
-	if (!VertexShaderCache::CompileVertexShader(s_vProgram, VProgram))
-		ERROR_LOG(VIDEO, "Failed to create texture converter vertex program.");
+		
+	ProgramShaderCache::CompileShader(s_rgbToYuyvProgram, VProgram, FProgramRgbToYuyv);
+	ProgramShaderCache::CompileShader(s_yuyvToRgbProgram, VProgram, FProgramYuyvToRgb);
 }
 
-FRAGMENTSHADER &GetOrCreateEncodingShader(u32 format)
+SHADER &GetOrCreateEncodingShader(u32 format)
 {
 	if (format > NUM_ENCODING_PROGRAMS)
 	{
@@ -149,9 +144,7 @@ FRAGMENTSHADER &GetOrCreateEncodingShader(u32 format)
 		}
 #endif
 
-		if (!PixelShaderCache::CompilePixelShader(s_encodingPrograms[format], shader)) {
-			ERROR_LOG(VIDEO, "Failed to create encoding fragment program");
-		}
+		ProgramShaderCache::CompileShader(s_encodingPrograms[format], VProgram, shader);
     }
 	return s_encodingPrograms[format];
 }
@@ -213,7 +206,6 @@ void Shutdown()
 
 	s_rgbToYuyvProgram.Destroy();
 	s_yuyvToRgbProgram.Destroy();
-	s_vProgram.Destroy();
 
 	for (unsigned int i = 0; i < NUM_ENCODING_PROGRAMS; i++)
 		s_encodingPrograms[i].Destroy();
@@ -325,9 +317,7 @@ int EncodeToRamFromTexture(u32 address,GLuint source_texture, bool bFromZBuffer,
 		if (copyfmt > GX_TF_RGBA8 || (copyfmt < GX_TF_RGB565 && !bIsIntensityFmt))
 			format |= _GX_TF_CTF;
 
-	FRAGMENTSHADER& texconv_shader = GetOrCreateEncodingShader(format);
-	if (texconv_shader.glprogid == 0)
-		return 0;
+	SHADER& texconv_shader = GetOrCreateEncodingShader(format);
 
 	u8 *dest_ptr = Memory::GetPointer(address);
 
@@ -344,8 +334,6 @@ int EncodeToRamFromTexture(u32 address,GLuint source_texture, bool bFromZBuffer,
 	// extra pixels are copied but not displayed in the resulting texture
 	s32 expandedWidth = (width + blkW) & (~blkW);
 	s32 expandedHeight = (height + blkH) & (~blkH);
-
-	ProgramShaderCache::SetBothShaders(texconv_shader.glprogid, s_vProgram.glprogid);
 		
 	float sampleStride = bScaleByHalf ? 2.f : 1.f;
 	
@@ -355,7 +343,9 @@ int EncodeToRamFromTexture(u32 address,GLuint source_texture, bool bFromZBuffer,
 		(float)expandedWidth, (float)Renderer::EFBToScaledY(expandedHeight)-1,
 		(float)Renderer::EFBToScaledX(source.left), (float)Renderer::EFBToScaledY(EFB_HEIGHT - source.top - expandedHeight)
 	};
-	glUniform4fv(ProgramShaderCache::GetShaderProgram().UniformLocations[C_COLORS], 2, params);
+
+	texconv_shader.Bind();
+	glUniform4fv(texconv_shader.UniformLocations[C_COLORS], 2, params);
 
 	TargetRectangle scaledSource;
 	scaledSource.top = 0;
@@ -379,7 +369,7 @@ void EncodeToRamYUYV(GLuint srcTexture, const TargetRectangle& sourceRc, u8* des
 {
 	g_renderer->ResetAPIState();
 	
-	ProgramShaderCache::SetBothShaders(s_rgbToYuyvProgram.glprogid, s_vProgram.glprogid);
+	s_rgbToYuyvProgram.Bind();
 		
 	EncodeToRamUsingShader(srcTexture, sourceRc, destAddr, dstWidth / 2, dstHeight, 0, false, false);
 	FramebufferManager::SetFramebuffer(0);
@@ -431,7 +421,7 @@ void DecodeToTexture(u32 xfbAddr, int srcWidth, int srcHeight, GLuint destRender
 	}
 
 	glViewport(0, 0, srcWidth, srcHeight);
-	ProgramShaderCache::SetBothShaders(s_yuyvToRgbProgram.glprogid, s_vProgram.glprogid);
+	s_yuyvToRgbProgram.Bind();
 
 	GL_REPORT_ERRORD();
 	
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp
index 59a78fa1a2..367f946caf 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp
@@ -29,9 +29,7 @@
 #include "ImageWrite.h"
 #include "BPMemory.h"
 #include "TextureCache.h"
-#include "PixelShaderCache.h"
 #include "PixelShaderManager.h"
-#include "VertexShaderCache.h"
 #include "VertexShaderManager.h"
 #include "ProgramShaderCache.h"
 #include "VertexShaderGen.h"
@@ -246,28 +244,23 @@ void VertexManager::vFlush()
 	bool dualSourcePossible = g_ActiveConfig.backend_info.bSupportsDualSourceBlend;
 
 	// finally bind
-	FRAGMENTSHADER* ps;
 	if (dualSourcePossible)
 	{
 		if (useDstAlpha)
 		{
 			// If host supports GL_ARB_blend_func_extended, we can do dst alpha in
 			// the same pass as regular rendering.
-			ps = PixelShaderCache::SetShader(DSTALPHA_DUAL_SOURCE_BLEND, g_nativeVertexFmt->m_components);
+			ProgramShaderCache::SetShader(DSTALPHA_DUAL_SOURCE_BLEND, g_nativeVertexFmt->m_components);
 		}
 		else
 		{
-			ps = PixelShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components);
+			ProgramShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components);
 		}
 	}
 	else
 	{
-		ps = PixelShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components);
+		ProgramShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components);
 	}
-	VERTEXSHADER* vs = VertexShaderCache::SetShader(g_nativeVertexFmt->m_components);
-	
-	if(ps && vs)
-		ProgramShaderCache::SetBothShaders(ps->glprogid, vs->glprogid);
 
 	// set global constants
 	VertexShaderManager::SetConstants();
@@ -284,9 +277,7 @@ void VertexManager::vFlush()
 	// run through vertex groups again to set alpha
 	if (useDstAlpha && !dualSourcePossible)
 	{
-		ps = PixelShaderCache::SetShader(DSTALPHA_ALPHA_PASS,g_nativeVertexFmt->m_components);
-		if(ps && vs)
-			ProgramShaderCache::SetBothShaders(ps->glprogid, vs->glprogid);
+		ProgramShaderCache::SetShader(DSTALPHA_ALPHA_PASS,g_nativeVertexFmt->m_components);
 		if (!g_ActiveConfig.backend_info.bSupportsGLSLUBO)
 		{
 			// Need to set these again, if we don't support UBO
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp
index 37a7b82485..038021c490 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp
@@ -27,7 +27,6 @@
 #include "VertexShaderGen.h"
 #include "VertexShaderManager.h"
 #include "ProgramShaderCache.h"
-#include "VertexShaderCache.h"
 #include "VertexManager.h"
 #include "VertexLoader.h"
 #include "XFMemory.h"
@@ -38,122 +37,6 @@
 namespace OGL
 {
 
-VertexShaderCache::VSCache VertexShaderCache::vshaders;
-GLuint VertexShaderCache::CurrentShader;
-bool VertexShaderCache::ShaderEnabled;
-
-VertexShaderCache::VSCacheEntry* VertexShaderCache::last_entry = NULL;
-VERTEXSHADERUID VertexShaderCache::last_uid;
-
-void VertexShaderCache::Init()
-{
-	ShaderEnabled = true;
-	CurrentShader = 0;
-	last_entry = NULL;
-}
-
-void VertexShaderCache::Shutdown()
-{
-	for (VSCache::iterator iter = vshaders.begin(); iter != vshaders.end(); ++iter)
-		iter->second.Destroy();
-	vshaders.clear();
-}
-
-VERTEXSHADER* VertexShaderCache::SetShader(u32 components)
-{
-	VERTEXSHADERUID uid;
-	GetVertexShaderId(&uid, components);
-	if (last_entry)
-	{
-		if (uid == last_uid)
-		{
-			GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-			ValidateVertexShaderIDs(API_OPENGL, vshaders[uid].safe_uid, vshaders[uid].shader.strprog, components);
-			return &last_entry->shader;
-		}
-	}
-
-	last_uid = uid;
-
-	VSCache::iterator iter = vshaders.find(uid);
-	if (iter != vshaders.end())
-	{
-		VSCacheEntry &entry = iter->second;
-		last_entry = &entry;
-
-		GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-		ValidateVertexShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, components);
-		return &last_entry->shader;
-	}
-
-	// Make an entry in the table
-	VSCacheEntry& entry = vshaders[uid];
-	last_entry = &entry;
-	const char *code = GenerateVertexShaderCode(components, API_OPENGL);
-	GetSafeVertexShaderId(&entry.safe_uid, components);
-
-#if defined(_DEBUG) || defined(DEBUGFAST)
-	if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) {
-		static int counter = 0;
-		char szTemp[MAX_PATH];
-		sprintf(szTemp, "%svs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
-
-		SaveData(szTemp, code);
-	}
-#endif
-
-	if (!code || !VertexShaderCache::CompileVertexShader(entry.shader, code)) {
-		GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
-		return NULL;
-	}
-
-	INCSTAT(stats.numVertexShadersCreated);
-	SETSTAT(stats.numVertexShadersAlive, vshaders.size());
-	GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-	return &last_entry->shader;
-}
-
-bool VertexShaderCache::CompileVertexShader(VERTEXSHADER& vs, const char* pstrprogram)
-{
-	GLuint result = glCreateShader(GL_VERTEX_SHADER);
-
-	glShaderSource(result, 1, &pstrprogram, NULL);
-	glCompileShader(result);
-#if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
-	GLsizei length = 0;
-	glGetShaderiv(result, GL_INFO_LOG_LENGTH, &length);
-	if (length > 1)
-	{
-		GLsizei charsWritten;
-		GLchar* infoLog = new GLchar[length];
-		glGetShaderInfoLog(result, length, &charsWritten, infoLog);
-		ERROR_LOG(VIDEO, "VS Shader info log:\n%s", infoLog);
-		char szTemp[MAX_PATH];
-		sprintf(szTemp, "vs_%d.txt", result);
-		FILE *fp = fopen(szTemp, "wb");
-		fwrite(infoLog, strlen(infoLog), 1, fp);
-		fwrite(pstrprogram, strlen(pstrprogram), 1, fp);
-		fclose(fp);
-		delete[] infoLog;
-	}
-
-	GLint compileStatus;
-	glGetShaderiv(result, GL_COMPILE_STATUS, &compileStatus);
-	if (compileStatus != GL_TRUE)
-	{
-		// Compile failed
-		ERROR_LOG(VIDEO, "Shader compilation failed; see info log");
-		
-		// Don't try to use this shader
-		glDeleteShader(result);
-		return false;
-	}
-#endif
-	(void)GL_REPORT_ERROR();
-	vs.glprogid = result;
-	return true;
-}
-
 void SetVSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1)
 {
 	ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram();
@@ -161,11 +44,11 @@ void SetVSConstant4fvByName(const char * name, unsigned int offset, const float
 	{
 		if (!strcmp(name, UniformNames[a]))
 		{
-			if (tmp.UniformLocations[a] == -1)
+			if (tmp.shader.UniformLocations[a] == -1)
 				return;
 			else
 			{
-				glUniform4fv(tmp.UniformLocations[a] + offset, count, f);
+				glUniform4fv(tmp.shader.UniformLocations[a] + offset, count, f);
 				return;
 			}
 		}
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h
deleted file mode 100644
index 9fd2a8ee9f..0000000000
--- a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#ifndef _VERTEXSHADERCACHE_H_
-#define _VERTEXSHADERCACHE_H_
-
-#include <map>
-#include <string>
-
-#include "BPMemory.h"
-#include "VertexShaderGen.h"
-
-namespace OGL
-{
-
-struct VERTEXSHADER
-{
-	VERTEXSHADER() : glprogid(0) {}
-	void Destroy()
-	{
-		glDeleteShader(glprogid);
-		glprogid = 0;
-	}
-	GLuint glprogid; // opengl program id
-
-	std::string strprog;
-};
-
-class VertexShaderCache
-{
-	struct VSCacheEntry
-	{ 
-		VERTEXSHADER shader;
-		VERTEXSHADERUIDSAFE safe_uid;
-		VSCacheEntry() {}
-		void Destroy() {
-			shader.Destroy();
-		}
-	};
-
-	typedef std::map<VERTEXSHADERUID, VSCacheEntry> VSCache;
-
-	static VSCache vshaders;
-
-	static VSCacheEntry* last_entry;
-	static VERTEXSHADERUID last_uid;
-
-	static GLuint CurrentShader;
-	static bool ShaderEnabled;
-
-public:
-	static void Init();
-	static void Shutdown();
-
-	static VERTEXSHADER* SetShader(u32 components);
-	static bool CompileVertexShader(VERTEXSHADER& ps, const char* pstrprogram);
-
-};
-}  // namespace OGL
-
-#endif // _VERTEXSHADERCACHE_H_
diff --git a/Source/Plugins/Plugin_VideoOGL/Src/main.cpp b/Source/Plugins/Plugin_VideoOGL/Src/main.cpp
index 51f44ec0c5..efa13eff76 100644
--- a/Source/Plugins/Plugin_VideoOGL/Src/main.cpp
+++ b/Source/Plugins/Plugin_VideoOGL/Src/main.cpp
@@ -79,9 +79,7 @@ Make AA apply instantly during gameplay if possible
 #include "VertexLoader.h"
 #include "VertexLoaderManager.h"
 #include "VertexManager.h"
-#include "PixelShaderCache.h"
 #include "PixelShaderManager.h"
-#include "VertexShaderCache.h"
 #include "VertexShaderManager.h"
 #include "ProgramShaderCache.h"
 #include "CommandProcessor.h"
@@ -194,9 +192,7 @@ void VideoBackend::Video_Prepare()
 	g_vertex_manager = new VertexManager;
 	Fifo_Init(); // must be done before OpcodeDecoder_Init()
 	OpcodeDecoder_Init();
-	VertexShaderCache::Init();
 	VertexShaderManager::Init();
-	PixelShaderCache::Init();
 	PixelShaderManager::Init();
 	ProgramShaderCache::Init();
 	g_texture_cache = new TextureCache;
@@ -232,10 +228,8 @@ void VideoBackend::Shutdown()
 		delete g_texture_cache;
 		g_texture_cache = NULL;
 		ProgramShaderCache::Shutdown();
-		VertexShaderCache::Shutdown();
 		VertexShaderManager::Shutdown();
 		PixelShaderManager::Shutdown();
-		PixelShaderCache::Shutdown();
 		delete g_vertex_manager;
 		g_vertex_manager = NULL;
 		OpcodeDecoder_Shutdown();