Merge branch 'const_buffer_rework'

13 files changed, 309 insertions, 478 deletions

diff --git a/Source/Core/VideoCommon/Src/BPStructs.cpp b/Source/Core/VideoCommon/Src/BPStructs.cpp
index 9f885e7953..cc169ffe8f 100644
--- a/Source/Core/VideoCommon/Src/BPStructs.cpp
+++ b/Source/Core/VideoCommon/Src/BPStructs.cpp
@@ -168,12 +168,16 @@ void BPWritten(const BPCmd& bp)
 	case BPMEM_IND_MTXA+6:
 	case BPMEM_IND_MTXB+6:
 	case BPMEM_IND_MTXC+6:
-		PixelShaderManager::SetIndMatrixChanged((bp.address - BPMEM_IND_MTXA) / 3);
+		if(bp.changes)
+			PixelShaderManager::SetIndMatrixChanged((bp.address - BPMEM_IND_MTXA) / 3);
 		break;
 	case BPMEM_RAS1_SS0: // Index Texture Coordinate Scale 0
-		PixelShaderManager::SetIndTexScaleChanged(0x03);
+		if(bp.changes)
+			PixelShaderManager::SetIndTexScaleChanged(false);
+		break;
 	case BPMEM_RAS1_SS1: // Index Texture Coordinate Scale 1
-		PixelShaderManager::SetIndTexScaleChanged(0x0c);
+		if(bp.changes)
+			PixelShaderManager::SetIndTexScaleChanged(true);
 		break;
 	// ----------------
 	// Scissor Control
@@ -220,7 +224,8 @@ void BPWritten(const BPCmd& bp)
 	case BPMEM_CONSTANTALPHA: // Set Destination Alpha
 		{
 			PRIM_LOG("constalpha: alp=%d, en=%d", bpmem.dstalpha.alpha, bpmem.dstalpha.enable);
-			PixelShaderManager::SetDestAlpha(bpmem.dstalpha);
+			if(bp.changes & 0xFF)
+				PixelShaderManager::SetDestAlpha();
 			if(bp.changes & 0x100)
 				SetBlendMode();
 			break;
@@ -341,29 +346,32 @@ void BPWritten(const BPCmd& bp)
 	case BPMEM_FOGRANGE+3:
 	case BPMEM_FOGRANGE+4:
 	case BPMEM_FOGRANGE+5:
-		if (!GetConfig(CONFIG_DISABLEFOG))
+		if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes)
 			PixelShaderManager::SetFogRangeAdjustChanged();
 		break;
 	case BPMEM_FOGPARAM0:
 	case BPMEM_FOGBMAGNITUDE:
 	case BPMEM_FOGBEXPONENT:
 	case BPMEM_FOGPARAM3:
-		if (!GetConfig(CONFIG_DISABLEFOG))
+		if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes)
 			PixelShaderManager::SetFogParamChanged();
 		break;
 	case BPMEM_FOGCOLOR: // Fog Color
-		if (!GetConfig(CONFIG_DISABLEFOG))
+		if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes)
 			PixelShaderManager::SetFogColorChanged();
 		break;
 	case BPMEM_ALPHACOMPARE: // Compare Alpha Values
 		PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", bpmem.alpha_test.ref0,
 				bpmem.alpha_test.ref1, bpmem.alpha_test.comp0, bpmem.alpha_test.comp1, bpmem.alpha_test.logic);
-		PixelShaderManager::SetAlpha(bpmem.alpha_test);
-		g_renderer->SetColorMask();
+		if(bp.changes & 0xFFFF)
+			PixelShaderManager::SetAlpha();
+		if(bp.changes)
+			g_renderer->SetColorMask();
 		break;
 	case BPMEM_BIAS: // BIAS
 		PRIM_LOG("ztex bias=0x%x", bpmem.ztex1.bias);
-		PixelShaderManager::SetZTextureBias(bpmem.ztex1.bias);
+		if(bp.changes)
+			PixelShaderManager::SetZTextureBias();
 		break;
 	case BPMEM_ZTEX2: // Z Texture type
 		{
@@ -573,7 +581,8 @@ void BPWritten(const BPCmd& bp)
 		case BPMEM_SU_TSIZE+12:
 		case BPMEM_SU_SSIZE+14:
 		case BPMEM_SU_TSIZE+14:
-			PixelShaderManager::SetTexCoordChanged((bp.address - BPMEM_SU_SSIZE) >> 1);
+			if(bp.changes)
+				PixelShaderManager::SetTexCoordChanged((bp.address - BPMEM_SU_SSIZE) >> 1);
 			break;
 		// ------------------------
 		// BPMEM_TX_SETMODE0 - (Texture lookup and filtering mode) LOD/BIAS Clamp, MaxAnsio, LODBIAS, DiagLoad, Min Filter, Mag Filter, Wrap T, S
@@ -627,9 +636,9 @@ void BPWritten(const BPCmd& bp)
 				// don't compare with changes!
 				int num = (bp.address >> 1) & 0x3;
 				if ((bp.address & 1) == 0)
-					PixelShaderManager::SetColorChanged(bpmem.tevregs[num].low.type, num, false);
+					PixelShaderManager::SetColorChanged(bpmem.tevregs[num].low.type, num);
 				else
-					PixelShaderManager::SetColorChanged(bpmem.tevregs[num].high.type, num, true);
+					PixelShaderManager::SetColorChanged(bpmem.tevregs[num].high.type, num);
 			}
 			break;
 
diff --git a/Source/Core/VideoCommon/Src/ConstantManager.h b/Source/Core/VideoCommon/Src/ConstantManager.h
new file mode 100644
index 0000000000..3c09c2007e
--- /dev/null
+++ b/Source/Core/VideoCommon/Src/ConstantManager.h
@@ -0,0 +1,42 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _CONSTANTMANAGER_H
+#define _CONSTANTMANAGER_H
+
+// all constant buffer attributes must be 16 bytes aligned, so this are the only allowed components:
+typedef float float4[4];
+typedef u32 uint4[4];
+typedef s32 int4[4];
+
+struct PixelShaderConstants
+{
+	float4 colors[4];
+	float4 kcolors[4];
+	float4 alpha;
+	float4 texdims[8];
+	float4 zbias[2];
+	float4 indtexscale[2];
+	float4 indtexmtx[6];
+	float4 fog[3];
+
+	// For pixel lighting
+	float4 plights[40];
+	float4 pmaterials[4];
+};
+
+struct VertexShaderConstants
+{
+	float4 posnormalmatrix[6];
+	float4 projection[4];
+	float4 materials[4];
+	float4 lights[40];
+	float4 texmatrices[24];
+	float4 transformmatrices[64];
+	float4 normalmatrices[32];
+	float4 posttransformmatrices[64];
+	float4 depthparams;
+};
+
+#endif
\ No newline at end of file
diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.h b/Source/Core/VideoCommon/Src/PixelShaderGen.h
index 5fbf28cd69..983e304998 100644
--- a/Source/Core/VideoCommon/Src/PixelShaderGen.h
+++ b/Source/Core/VideoCommon/Src/PixelShaderGen.h
@@ -21,6 +21,7 @@
 #define I_PLIGHTS     "cPLights"
 #define I_PMATERIALS  "cPmtrl"
 
+// TODO: get rid of them as they aren't used
 #define C_COLORMATRIX	0						// 0
 #define C_COLORS		0						// 0
 #define C_KCOLORS		(C_COLORS + 4)			// 4
@@ -43,19 +44,6 @@ enum DSTALPHA_MODE
 	DSTALPHA_DUAL_SOURCE_BLEND // Use dual-source blending
 };
 
-// Annoying sure, can be removed once we get up to GLSL ~1.3
-const s_svar PSVar_Loc[] = { {I_COLORS, C_COLORS, 4 },
-						{I_KCOLORS, C_KCOLORS, 4 },
-						{I_ALPHA, C_ALPHA, 1 },
-						{I_TEXDIMS, C_TEXDIMS, 8 },
-						{I_ZBIAS , C_ZBIAS, 2  },
-						{I_INDTEXSCALE , C_INDTEXSCALE, 2  },
-						{I_INDTEXMTX, C_INDTEXMTX, 6 },
-						{I_FOG, C_FOG, 3 },
-						{I_PLIGHTS, C_PLIGHTS, 40 },
-						{I_PMATERIALS, C_PMATERIALS, 4 },
-						};
-
 #pragma pack(1)
 struct pixel_shader_uid_data
 {
diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
index aef4baa14c..c773e734d6 100644
--- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
+++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
@@ -11,58 +11,51 @@
 #include "VideoConfig.h"
 
 #include "RenderBase.h"
-static int s_nColorsChanged[2]; // 0 - regular colors, 1 - k colors
-static int s_nIndTexMtxChanged;
-static bool s_bAlphaChanged;
-static bool s_bZBiasChanged;
-static bool s_bZTextureTypeChanged;
-static bool s_bDepthRangeChanged;
-static bool s_bFogColorChanged;
-static bool s_bFogParamChanged;
 static bool s_bFogRangeAdjustChanged;
 static int nLightsChanged[2]; // min,max
-static float lastRGBAfull[2][4][4];
-static u8 s_nTexDimsChanged;
-static u8 s_nIndTexScaleChanged;
-static u32 lastAlpha;
-static u32 lastTexDims[8]; // width | height << 16 | wrap_s << 28 | wrap_t << 30
-static u32 lastZBias;
-static int nMaterialsChanged;
-
-inline void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
-{
-	g_renderer->SetPSConstant4f(const_number, f1, f2, f3, f4);
-}
 
-inline void SetPSConstant4fv(unsigned int const_number, const float *f)
-{
-	g_renderer->SetPSConstant4fv(const_number, f);
-}
-
-inline void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f)
-{
-	g_renderer->SetMultiPSConstant4fv(const_number, count, f);
-}
+PixelShaderConstants PixelShaderManager::constants;
+bool PixelShaderManager::dirty;
 
 void PixelShaderManager::Init()
 {
-	lastAlpha = 0;
-	memset(lastTexDims, 0, sizeof(lastTexDims));
-	lastZBias = 0;
-	memset(lastRGBAfull, 0, sizeof(lastRGBAfull));
+	memset(&constants, 0, sizeof(constants));
 	Dirty();
 }
 
 void PixelShaderManager::Dirty()
 {
-	s_nColorsChanged[0] = s_nColorsChanged[1] = 15;
-	s_nTexDimsChanged = 0xFF;
-	s_nIndTexScaleChanged = 0xFF;
-	s_nIndTexMtxChanged = 15;
-	s_bAlphaChanged = s_bZBiasChanged = s_bZTextureTypeChanged = s_bDepthRangeChanged = true;
-	s_bFogRangeAdjustChanged = s_bFogColorChanged = s_bFogParamChanged = true;
+	s_bFogRangeAdjustChanged = true;
 	nLightsChanged[0] = 0; nLightsChanged[1] = 0x80;
-	nMaterialsChanged = 15;
+	
+	SetColorChanged(0, 0);
+	SetColorChanged(0, 1);
+	SetColorChanged(0, 2);
+	SetColorChanged(0, 3);
+	SetColorChanged(1, 0);
+	SetColorChanged(1, 1);
+	SetColorChanged(1, 2);
+	SetColorChanged(1, 3);
+	SetAlpha();
+	SetDestAlpha();
+	SetZTextureBias();
+	SetViewportChanged();
+	SetIndTexScaleChanged(false);
+	SetIndTexScaleChanged(true);
+	SetIndMatrixChanged(0);
+	SetIndMatrixChanged(1);
+	SetIndMatrixChanged(2);
+	SetZTextureTypeChanged();
+	SetTexCoordChanged(0);
+	SetTexCoordChanged(1);
+	SetTexCoordChanged(2);
+	SetTexCoordChanged(3);
+	SetTexCoordChanged(4);
+	SetTexCoordChanged(5);
+	SetTexCoordChanged(6);
+	SetTexCoordChanged(7);
+	SetFogColorChanged();
+	SetFogParamChanged();
 }
 
 void PixelShaderManager::Shutdown()
@@ -72,169 +65,10 @@ void PixelShaderManager::Shutdown()
 
 void PixelShaderManager::SetConstants(u32 components)
 {
-	if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO)
-		Dirty();
-
-	for (int i = 0; i < 2; ++i)
-	{
-		if (s_nColorsChanged[i])
-		{
-			int baseind = i ? C_KCOLORS : C_COLORS;
-			for (int j = 0; j < 4; ++j)
-			{
-				if ((s_nColorsChanged[i] & (1 << j)))
-				{
-					SetPSConstant4fv(baseind+j, &lastRGBAfull[i][j][0]);
-					s_nColorsChanged[i] &= ~(1<<j);
-				}
-			}
-		}
-	}
-
-    if (s_nTexDimsChanged)
-	{
-		for (int i = 0; i < 8; ++i)
-		{
-            if ((s_nTexDimsChanged & (1<<i)))
-			{
-				SetPSTextureDims(i);
-				s_nTexDimsChanged &= ~(1<<i);
-			}
-        }
-    }
-
-    if (s_bAlphaChanged)
-	{
-		SetPSConstant4f(C_ALPHA, (lastAlpha&0xff)/255.0f, ((lastAlpha>>8)&0xff)/255.0f, 0, ((lastAlpha>>16)&0xff)/255.0f);
-		s_bAlphaChanged = false;
-    }
-
-	if (s_bZTextureTypeChanged)
-	{
-		float ftemp[4];
-		switch (bpmem.ztex2.type)
-		{
-			 case 0:
-				// 8 bits
-				ftemp[0] = 0; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 255.0f/16777215.0f;
-				break;
-			case 1:
-				// 16 bits
-				ftemp[0] = 255.0f/16777215.0f; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 65280.0f/16777215.0f;
-				break;
-			case 2:
-				// 24 bits
-				ftemp[0] = 16711680.0f/16777215.0f; ftemp[1] = 65280.0f/16777215.0f; ftemp[2] = 255.0f/16777215.0f; ftemp[3] = 0;
-                break;
-        }
-		SetPSConstant4fv(C_ZBIAS, ftemp);
-		s_bZTextureTypeChanged = false;
-	}
-
-	if (s_bZBiasChanged || s_bDepthRangeChanged)
-	{
-		// reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
-		// [0] = width/2
-		// [1] = height/2
-		// [2] = 16777215 * (farz - nearz)
-		// [3] = xorig + width/2 + 342
-		// [4] = yorig + height/2 + 342
-		// [5] = 16777215 * farz
-
-		//ERROR_LOG("pixel=%x,%x, bias=%x\n", bpmem.zcontrol.pixel_format, bpmem.ztex2.type, lastZBias);
-		SetPSConstant4f(C_ZBIAS+1, xfregs.viewport.farZ / 16777216.0f, xfregs.viewport.zRange / 16777216.0f, 0, (float)(lastZBias)/16777215.0f);
-		s_bZBiasChanged = s_bDepthRangeChanged = false;
-	}
-
-	// indirect incoming texture scales
-	if (s_nIndTexScaleChanged)
-	{
-		// set as two sets of vec4s, each containing S and T of two ind stages.
-		float f[8];
-
-        if (s_nIndTexScaleChanged & 0x03)
-		{
-			for (u32 i = 0; i < 2; ++i)
-			{
-                f[2 * i] = bpmem.texscale[0].getScaleS(i & 1);
-                f[2 * i + 1] = bpmem.texscale[0].getScaleT(i & 1);
-                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
-            }
-			SetPSConstant4fv(C_INDTEXSCALE, f);
-        }
-
-		if (s_nIndTexScaleChanged & 0x0c)
-		{
-            for (u32 i = 2; i < 4; ++i)
-			{
-                f[2 * i] = bpmem.texscale[1].getScaleS(i & 1);
-                f[2 * i + 1] = bpmem.texscale[1].getScaleT(i & 1);
-                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
-            }
-			SetPSConstant4fv(C_INDTEXSCALE+1, &f[4]);
-        }
-		s_nIndTexScaleChanged = 0;
-    }
-
-	if (s_nIndTexMtxChanged)
-	{
-		for (int i = 0; i < 3; ++i)
-		{
-            if (s_nIndTexMtxChanged & (1 << i))
-			{
-                int scale = ((u32)bpmem.indmtx[i].col0.s0 << 0) |
-					        ((u32)bpmem.indmtx[i].col1.s1 << 2) |
-					        ((u32)bpmem.indmtx[i].col2.s2 << 4);
-                float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f;
-
-                // xyz - static matrix
-                // TODO w - dynamic matrix scale / 256...... somehow / 4 works better
-                // rev 2972 - now using / 256.... verify that this works
-				SetPSConstant4f(C_INDTEXMTX + 2 * i,
-					bpmem.indmtx[i].col0.ma * fscale,
-					bpmem.indmtx[i].col1.mc * fscale,
-					bpmem.indmtx[i].col2.me * fscale,
-					fscale * 4.0f);
-				SetPSConstant4f(C_INDTEXMTX + 2 * i + 1,
-					bpmem.indmtx[i].col0.mb * fscale,
-					bpmem.indmtx[i].col1.md * fscale,
-					bpmem.indmtx[i].col2.mf * fscale,
-					fscale * 4.0f);
-
-                PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n",
-                	i, 1024.0f*fscale,
-                	bpmem.indmtx[i].col0.ma * fscale, bpmem.indmtx[i].col1.mc * fscale, bpmem.indmtx[i].col2.me * fscale,
-                	bpmem.indmtx[i].col0.mb * fscale, bpmem.indmtx[i].col1.md * fscale, bpmem.indmtx[i].col2.mf * fscale);
-
-				s_nIndTexMtxChanged &= ~(1 << i);
-			}
-        }
-    }
-
-    if (s_bFogColorChanged)
-	{
-		SetPSConstant4f(C_FOG, bpmem.fog.color.r / 255.0f, bpmem.fog.color.g / 255.0f, bpmem.fog.color.b / 255.0f, 0);
-		s_bFogColorChanged = false;
-    }
-
-    if (s_bFogParamChanged)
-	{
-		if(!g_ActiveConfig.bDisableFog)
-		{
-			//downscale magnitude to 0.24 bits
-			float b = (float)bpmem.fog.b_magnitude / 0xFFFFFF;
-
-			float b_shf = (float)(1 << bpmem.fog.b_shift);
-			SetPSConstant4f(C_FOG + 1, bpmem.fog.a.GetA(), b, bpmem.fog.c_proj_fsel.GetC(), b_shf);
-		}
-		else
-			SetPSConstant4f(C_FOG + 1, 0.0, 1.0, 0.0, 1.0);
-
-        s_bFogParamChanged = false;
-    }
-
 	if (s_bFogRangeAdjustChanged)
 	{
+		// set by two components, so keep changed flag here
+		// TODO: try to split both registers and move this logic to the shader
 		if(!g_ActiveConfig.bDisableFog && bpmem.fogRange.Base.Enabled == 1)
 		{
 			//bpmem.fogRange.Base.Center : center of the viewport in x axis. observation: bpmem.fogRange.Base.Center = realcenter + 342;
@@ -247,12 +81,17 @@ void PixelShaderManager::SetConstants(u32 components)
 			// they always seems to be larger than 256 so my theory is :
 			// they are the coefficients from the center to the border of the screen
 			// so to simplify I use the hi coefficient as K in the shader taking 256 as the scale
-			SetPSConstant4f(C_FOG + 2, ScreenSpaceCenter, (float)Renderer::EFBToScaledX((int)(2.0f * xfregs.viewport.wd)), bpmem.fogRange.K[4].HI / 256.0f,0.0f);
+			constants.fog[2][0] = ScreenSpaceCenter;
+			constants.fog[2][1] = Renderer::EFBToScaledX((int)(2.0f * xfregs.viewport.wd));
+			constants.fog[2][2] = bpmem.fogRange.K[4].HI / 256.0f;
 		}
 		else
 		{
-			SetPSConstant4f(C_FOG + 2, 0.0f, 1.0f, 1.0f, 0.0f); // Need to update these values for older hardware that fails to divide by zero in shaders.
+			constants.fog[2][0] = 0;
+			constants.fog[2][1] = 1;
+			constants.fog[2][2] = 1;
 		}
+		dirty = true;
 
 		s_bFogRangeAdjustChanged = false;
 	}
@@ -269,12 +108,10 @@ void PixelShaderManager::SetConstants(u32 components)
 			for (int i = istart; i < iend; ++i)
 			{
 				u32 color = *(const u32*)(xfmemptr + 3);
-				float NormalizationCoef = 1 / 255.0f;
-				SetPSConstant4f(C_PLIGHTS + 5 * i,
-					((color >> 24) & 0xFF) * NormalizationCoef,
-					((color >> 16) & 0xFF) * NormalizationCoef,
-					((color >> 8)  & 0xFF) * NormalizationCoef,
-					((color)       & 0xFF) * NormalizationCoef);
+				constants.plights[5*i][0] = ((color >> 24) & 0xFF) / 255.0f;
+				constants.plights[5*i][1] = ((color >> 16) & 0xFF) / 255.0f;
+				constants.plights[5*i][2] = ((color >> 8)  & 0xFF) / 255.0f;
+				constants.plights[5*i][3] = ((color)       & 0xFF) / 255.0f;
 				xfmemptr += 4;
 
 				for (int j = 0; j < 4; ++j, xfmemptr += 3)
@@ -283,174 +120,173 @@ void PixelShaderManager::SetConstants(u32 components)
 						fabs(xfmemptr[0]) < 0.00001f &&
 						fabs(xfmemptr[1]) < 0.00001f &&
 						fabs(xfmemptr[2]) < 0.00001f)
-					{
 						// dist attenuation, make sure not equal to 0!!!
-						SetPSConstant4f(C_PLIGHTS+5*i+j+1, 0.00001f, xfmemptr[1], xfmemptr[2], 0);
-					}
+						constants.plights[5*i+j+1][0] = 0.00001f;
 					else
-					{
-						SetPSConstant4fv(C_PLIGHTS+5*i+j+1, xfmemptr);
-					}
+						constants.plights[5*i+j+1][0] = xfmemptr[0];
+					constants.plights[5*i+j+1][1] = xfmemptr[1];
+					constants.plights[5*i+j+1][2] = xfmemptr[2];
 				}
 			}
+			dirty = true;
 
 			nLightsChanged[0] = nLightsChanged[1] = -1;
 		}
-
-		if (nMaterialsChanged)
-		{
-			float GC_ALIGNED16(material[4]);
-			float NormalizationCoef = 1 / 255.0f;
-
-			for (int i = 0; i < 2; ++i)
-			{
-				if (nMaterialsChanged & (1 << i))
-				{
-					u32 data = *(xfregs.ambColor + i);
-
-					material[0] = ((data >> 24) & 0xFF) * NormalizationCoef;
-					material[1] = ((data >> 16) & 0xFF) * NormalizationCoef;
-					material[2] = ((data >>  8) & 0xFF) * NormalizationCoef;
-					material[3] = ( data        & 0xFF) * NormalizationCoef;
-
-					SetPSConstant4fv(C_PMATERIALS + i, material);
-				}
-			}
-
-			for (int i = 0; i < 2; ++i)
-			{
-				if (nMaterialsChanged & (1 << (i + 2)))
-				{
-					u32 data = *(xfregs.matColor + i);
-
-					material[0] = ((data >> 24) & 0xFF) * NormalizationCoef;
-					material[1] = ((data >> 16) & 0xFF) * NormalizationCoef;
-					material[2] = ((data >>  8) & 0xFF) * NormalizationCoef;
-					material[3] = ( data        & 0xFF) * NormalizationCoef;
-
-					SetPSConstant4fv(C_PMATERIALS + i + 2, material);
-				}
-			}
-
-			nMaterialsChanged = 0;
-		}
 	}
 }
 
-void PixelShaderManager::SetPSTextureDims(int texid)
-{
-	// texdims.xy are reciprocals of the real texture dimensions
-	// texdims.zw are the scaled dimensions
-	float fdims[4];
-
-	TCoordInfo& tc = bpmem.texcoords[texid];
-	fdims[0] = 1.0f / (float)(lastTexDims[texid] & 0xffff);
-	fdims[1] = 1.0f / (float)((lastTexDims[texid] >> 16) & 0xfff);
-	fdims[2] = (float)(tc.s.scale_minus_1 + 1);
-	fdims[3] = (float)(tc.t.scale_minus_1 + 1);
-
-	PRIM_LOG("texdims%d: %f %f %f %f\n", texid, fdims[0], fdims[1], fdims[2], fdims[3]);
-	SetPSConstant4fv(C_TEXDIMS + texid, fdims);
-}
-
 // This one is high in profiles (0.5%).
 // TODO: Move conversion out, only store the raw color value
 // and update it when the shader constant is set, only.
 // TODO: Conversion should be checked in the context of tev_fixes..
-void PixelShaderManager::SetColorChanged(int type, int num, bool high)
+void PixelShaderManager::SetColorChanged(int type, int num)
 {
-	float *pf = &lastRGBAfull[type][num][0];
-
-	if (!high)
-	{
-		int r = bpmem.tevregs[num].low.a;
-		int a = bpmem.tevregs[num].low.b;
-		pf[0] = (float)r * (1.0f / 255.0f);
-		pf[3] = (float)a * (1.0f / 255.0f);
-	}
-	else
-	{
-		int b = bpmem.tevregs[num].high.a;
-		int g = bpmem.tevregs[num].high.b;
-		pf[1] = (float)g * (1.0f / 255.0f);
-		pf[2] = (float)b * (1.0f / 255.0f);
-	}
-
-	s_nColorsChanged[type] |= 1 << num;
-	PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, pf[0], pf[1], pf[2], pf[3]);
+	float4* c = type ? constants.kcolors : constants.colors;
+	c[num][0] = bpmem.tevregs[num].low.a / 255.0f;
+	c[num][3] = bpmem.tevregs[num].low.b / 255.0f;
+	c[num][2] = bpmem.tevregs[num].high.a / 255.0f;
+	c[num][1] = bpmem.tevregs[num].high.b / 255.0f;
+	dirty = true;
+	
+	PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, c[num][0], c[num][1], c[num][2], c[num][3]);
 }
 
-void PixelShaderManager::SetAlpha(const AlphaTest& alpha)
+void PixelShaderManager::SetAlpha()
 {
-	if ((alpha.hex & 0xffff) != lastAlpha)
-	{
-		lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff);
-		s_bAlphaChanged = true;
-	}
+	constants.alpha[0] = bpmem.alpha_test.ref0 / 255.0f;
+	constants.alpha[1] = bpmem.alpha_test.ref1 / 255.0f;
+	dirty = true;
 }
 
-void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha)
+void PixelShaderManager::SetDestAlpha()
 {
-	if (alpha.alpha != (lastAlpha >> 16))
-	{
-		lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16);
-		s_bAlphaChanged = true;
-	}
+	constants.alpha[3] = bpmem.dstalpha.alpha / 255.0f;
+	dirty = true;
 }
 
 void PixelShaderManager::SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt)
 {
-	u32 wh = width | (height << 16) | (wraps << 28) | (wrapt << 30);
-	if (lastTexDims[texmapid] != wh)
-	{
-		lastTexDims[texmapid] = wh;
-		s_nTexDimsChanged |= 1 << texmapid;
-	}
+	// TODO: move this check out to callee. There we could just call this function on texture changes
+	// or better, use textureSize() in glsl
+	if(constants.texdims[texmapid][0] != 1.0f/width || constants.texdims[texmapid][1] != 1.0f/height)
+		dirty = true;
+	
+	constants.texdims[texmapid][0] = 1.0f/width;
+	constants.texdims[texmapid][1] = 1.0f/height;
 }
 
-void PixelShaderManager::SetZTextureBias(u32 bias)
+void PixelShaderManager::SetZTextureBias()
 {
-	if (lastZBias != bias)
-	{
-		s_bZBiasChanged = true;
-		lastZBias = bias;
-	}
+	constants.zbias[1][3] = bpmem.ztex1.bias/16777215.0f;
+	dirty = true;
 }
 
 void PixelShaderManager::SetViewportChanged()
 {
-	s_bDepthRangeChanged = true;
+	constants.zbias[1][0] = xfregs.viewport.farZ / 16777216.0f;
+	constants.zbias[1][1] = xfregs.viewport.zRange / 16777216.0f;
+	dirty = true;
+	
 	s_bFogRangeAdjustChanged = true; // TODO: Shouldn't be necessary with an accurate fog range adjust implementation
 }
 
-void PixelShaderManager::SetIndTexScaleChanged(u8 stagemask)
+void PixelShaderManager::SetIndTexScaleChanged(bool high)
 {
-	s_nIndTexScaleChanged |= stagemask;
+	constants.indtexscale[high][0] = bpmem.texscale[high].getScaleS(0);
+	constants.indtexscale[high][1] = bpmem.texscale[high].getScaleT(0);
+	constants.indtexscale[high][2] = bpmem.texscale[high].getScaleS(1);
+	constants.indtexscale[high][3] = bpmem.texscale[high].getScaleT(1);
+	dirty = true;
 }
 
 void PixelShaderManager::SetIndMatrixChanged(int matrixidx)
 {
-	s_nIndTexMtxChanged |= 1 << matrixidx;
+	int scale = ((u32)bpmem.indmtx[matrixidx].col0.s0 << 0) |
+			((u32)bpmem.indmtx[matrixidx].col1.s1 << 2) |
+			((u32)bpmem.indmtx[matrixidx].col2.s2 << 4);
+	float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f;
+
+	// xyz - static matrix
+	// TODO w - dynamic matrix scale / 256...... somehow / 4 works better
+	// rev 2972 - now using / 256.... verify that this works
+	constants.indtexmtx[2*matrixidx][0] = bpmem.indmtx[matrixidx].col0.ma * fscale;
+	constants.indtexmtx[2*matrixidx][1] = bpmem.indmtx[matrixidx].col1.mc * fscale;
+	constants.indtexmtx[2*matrixidx][2] = bpmem.indmtx[matrixidx].col2.me * fscale;
+	constants.indtexmtx[2*matrixidx][3] = fscale * 4.0f;
+	constants.indtexmtx[2*matrixidx+1][0] = bpmem.indmtx[matrixidx].col0.mb * fscale;
+	constants.indtexmtx[2*matrixidx+1][1] = bpmem.indmtx[matrixidx].col1.md * fscale;
+	constants.indtexmtx[2*matrixidx+1][2] = bpmem.indmtx[matrixidx].col2.mf * fscale;
+	constants.indtexmtx[2*matrixidx+1][3] = fscale * 4.0f;
+	dirty = true;
+
+	PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n",
+			matrixidx, 1024.0f*fscale,
+			bpmem.indmtx[matrixidx].col0.ma * fscale, bpmem.indmtx[matrixidx].col1.mc * fscale, bpmem.indmtx[matrixidx].col2.me * fscale,
+		bpmem.indmtx[matrixidx].col0.mb * fscale, bpmem.indmtx[matrixidx].col1.md * fscale, bpmem.indmtx[matrixidx].col2.mf * fscale);
+
 }
 
 void PixelShaderManager::SetZTextureTypeChanged()
 {
-	s_bZTextureTypeChanged = true;
+	switch (bpmem.ztex2.type)
+	{
+		case TEV_ZTEX_TYPE_U8:
+			constants.zbias[0][0] = 0;
+			constants.zbias[0][1] = 0;
+			constants.zbias[0][2] = 0;
+			constants.zbias[0][3] = 255.0f/16777215.0f;
+			break;
+		case TEV_ZTEX_TYPE_U16:
+			constants.zbias[0][0] = 255.0f/16777215.0f;
+			constants.zbias[0][1] = 0;
+			constants.zbias[0][2] = 0;
+			constants.zbias[0][3] = 65280.0f/16777215.0f;
+			break;
+		case TEV_ZTEX_TYPE_U24:
+			constants.zbias[0][0] = 16711680.0f/16777215.0f;
+			constants.zbias[0][1] = 65280.0f/16777215.0f;
+			constants.zbias[0][2] = 255.0f/16777215.0f;
+			constants.zbias[0][3] = 0;
+			break;
+		default:
+			break;
+        }
+        dirty = true;
 }
 
 void PixelShaderManager::SetTexCoordChanged(u8 texmapid)
 {
-	s_nTexDimsChanged |= 1 << texmapid;
+	TCoordInfo& tc = bpmem.texcoords[texmapid];
+        constants.texdims[texmapid][2] = tc.s.scale_minus_1 + 1;
+	constants.texdims[texmapid][3] = tc.t.scale_minus_1 + 1;
+	dirty = true;
 }
 
 void PixelShaderManager::SetFogColorChanged()
 {
-	s_bFogColorChanged = true;
+	constants.fog[0][0] = bpmem.fog.color.r / 255.0f;
+	constants.fog[0][1] = bpmem.fog.color.g / 255.0f;
+	constants.fog[0][2] = bpmem.fog.color.b / 255.0f;
+	dirty = true;
 }
 
 void PixelShaderManager::SetFogParamChanged()
 {
-	s_bFogParamChanged = true;
+	if(!g_ActiveConfig.bDisableFog)
+	{
+		constants.fog[1][0] = bpmem.fog.a.GetA();
+		constants.fog[1][1] = (float)bpmem.fog.b_magnitude / 0xFFFFFF;
+		constants.fog[1][2] = bpmem.fog.c_proj_fsel.GetC();
+		constants.fog[1][3] = 1 << bpmem.fog.b_shift;
+	}
+	else
+	{
+		constants.fog[1][0] = 0;
+		constants.fog[1][1] = 1;
+		constants.fog[1][2] = 0;
+		constants.fog[1][3] = 1;
+	}
+	dirty = true;
 }
 
 void PixelShaderManager::SetFogRangeAdjustChanged()
@@ -458,12 +294,6 @@ void PixelShaderManager::SetFogRangeAdjustChanged()
 	s_bFogRangeAdjustChanged = true;
 }
 
-void PixelShaderManager::SetColorMatrix(const float* pmatrix)
-{
-	SetMultiPSConstant4fv(C_COLORMATRIX,7,pmatrix);
-	s_nColorsChanged[0] = s_nColorsChanged[1] = 15;
-}
-
 void PixelShaderManager::InvalidateXFRange(int start, int end)
 {
 	if (start < XFMEM_LIGHTS_END && end > XFMEM_LIGHTS)
@@ -484,18 +314,23 @@ void PixelShaderManager::InvalidateXFRange(int start, int end)
 	}
 }
 
-void PixelShaderManager::SetMaterialColorChanged(int index)
+void PixelShaderManager::SetMaterialColorChanged(int index, u32 color)
 {
-	nMaterialsChanged  |= (1 << index);
+	if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting)
+	{
+		constants.pmaterials[index][0] = ((color >> 24) & 0xFF) / 255.0f;
+		constants.pmaterials[index][1] = ((color >> 16) & 0xFF) / 255.0f;
+		constants.pmaterials[index][2] = ((color >>  8) & 0xFF) / 255.0f;
+		constants.pmaterials[index][3] = ( color        & 0xFF) / 255.0f;
+		dirty = true;
+	}
 }
 
 void PixelShaderManager::DoState(PointerWrap &p)
 {
-	p.Do(lastRGBAfull);
-	p.Do(lastAlpha);
-	p.Do(lastTexDims);
-	p.Do(lastZBias);
-
+	p.Do(constants);
+	p.Do(dirty);
+	
 	if (p.GetMode() == PointerWrap::MODE_READ)
 	{
 		Dirty();
diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.h b/Source/Core/VideoCommon/Src/PixelShaderManager.h
index 7f63fb3f46..c68ae569a2 100644
--- a/Source/Core/VideoCommon/Src/PixelShaderManager.h
+++ b/Source/Core/VideoCommon/Src/PixelShaderManager.h
@@ -8,13 +8,15 @@
 #include "BPMemory.h"
 #include "XFMemory.h"
 #include "PixelShaderGen.h"
+#include "ConstantManager.h"
 
 class PointerWrap;
 
+
+
 // The non-API dependent parts.
 class PixelShaderManager
 {
-	static void SetPSTextureDims(int texid);
 public:
 	static void Init();
 	static void Dirty();
@@ -24,23 +26,25 @@ public:
 	static void SetConstants(u32 components); // sets pixel shader constants
 
 	// constant management, should be called after memory is committed
-	static void SetColorChanged(int type, int index, bool high);
-	static void SetAlpha(const AlphaTest& alpha);
-	static void SetDestAlpha(const ConstantAlpha& alpha);
+	static void SetColorChanged(int type, int index);
+	static void SetAlpha();
+	static void SetDestAlpha();
 	static void SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt);
-	static void SetZTextureBias(u32 bias);
+	static void SetZTextureBias();
 	static void SetViewportChanged();
 	static void SetIndMatrixChanged(int matrixidx);
 	static void SetTevKSelChanged(int id);
 	static void SetZTextureTypeChanged();
-	static void SetIndTexScaleChanged(u8 stagemask);
+	static void SetIndTexScaleChanged(bool high);
 	static void SetTexCoordChanged(u8 texmapid);
 	static void SetFogColorChanged();
 	static void SetFogParamChanged();
 	static void SetFogRangeAdjustChanged();
-	static void SetColorMatrix(const float* pmatrix);
 	static void InvalidateXFRange(int start, int end);
-	static void SetMaterialColorChanged(int index);
+	static void SetMaterialColorChanged(int index, u32 color);
+	
+	static PixelShaderConstants constants;
+	static bool dirty;
 };
 
 
diff --git a/Source/Core/VideoCommon/Src/RenderBase.h b/Source/Core/VideoCommon/Src/RenderBase.h
index 7d9f3f857c..4e093700a9 100644
--- a/Source/Core/VideoCommon/Src/RenderBase.h
+++ b/Source/Core/VideoCommon/Src/RenderBase.h
@@ -115,17 +115,6 @@ public:
 	static unsigned int GetPrevPixelFormat() { return prev_efb_format; }
 	static void StorePixelFormat(unsigned int new_format) { prev_efb_format = new_format; }
 
-	// TODO: doesn't belong here
-	virtual void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) = 0;
-	virtual void SetPSConstant4fv(unsigned int const_number, const float *f) = 0;
-	virtual void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0;
-
-	// TODO: doesn't belong here
-	virtual void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) = 0;
-	virtual void SetVSConstant4fv(unsigned int const_number, const float *f) = 0;
-	virtual void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) = 0;
-	virtual void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0;
-
 protected:
 
 	static void CalculateTargetScale(int x, int y, int &scaledX, int &scaledY);
diff --git a/Source/Core/VideoCommon/Src/TextureConversionShader.cpp b/Source/Core/VideoCommon/Src/TextureConversionShader.cpp
index 7916e47c12..9b6c8762ff 100644
--- a/Source/Core/VideoCommon/Src/TextureConversionShader.cpp
+++ b/Source/Core/VideoCommon/Src/TextureConversionShader.cpp
@@ -867,10 +867,4 @@ const char *GenerateEncodingShader(u32 format,API_TYPE ApiType)
 	return text;
 }
 
-void SetShaderParameters(float width, float height, float offsetX, float offsetY, float widthStride, float heightStride,float buffW,float buffH)
-{
-	g_renderer->SetPSConstant4f(C_COLORMATRIX, widthStride, heightStride, buffW, buffH);
-	g_renderer->SetPSConstant4f(C_COLORMATRIX + 1, width, (height - 1), offsetX, offsetY);
-}
-
 }  // namespace
diff --git a/Source/Core/VideoCommon/Src/TextureConversionShader.h b/Source/Core/VideoCommon/Src/TextureConversionShader.h
index aa42726b2c..843c5ef7ee 100644
--- a/Source/Core/VideoCommon/Src/TextureConversionShader.h
+++ b/Source/Core/VideoCommon/Src/TextureConversionShader.h
@@ -15,8 +15,6 @@ u16 GetEncodedSampleCount(u32 format);
 
 const char *GenerateEncodingShader(u32 format, API_TYPE ApiType = API_OPENGL);
 
-void SetShaderParameters(float width, float height, float offsetX, float offsetY, float widthStride, float heightStride,float buffW = 0.0f,float buffH = 0.0f);
-
 }
 
 #endif // _TEXTURECONVERSIONSHADER_H_
diff --git a/Source/Core/VideoCommon/Src/VertexShaderGen.h b/Source/Core/VideoCommon/Src/VertexShaderGen.h
index 0ec703c07f..9664e92359 100644
--- a/Source/Core/VideoCommon/Src/VertexShaderGen.h
+++ b/Source/Core/VideoCommon/Src/VertexShaderGen.h
@@ -42,6 +42,7 @@
 #define I_POSTTRANSFORMMATRICES "cpostmtx"
 #define I_DEPTHPARAMS           "cDepth" // farZ, zRange, scaled viewport width, scaled viewport height
 
+//TODO: get rid of them, they aren't used at all
 #define C_POSNORMALMATRIX        0
 #define C_PROJECTION            (C_POSNORMALMATRIX + 6)
 #define C_MATERIALS             (C_PROJECTION + 4)
@@ -53,17 +54,6 @@
 #define C_DEPTHPARAMS           (C_POSTTRANSFORMMATRICES + 64)
 #define C_VENVCONST_END			(C_DEPTHPARAMS + 1)
 
-const s_svar VSVar_Loc[] = {  {I_POSNORMALMATRIX, C_POSNORMALMATRIX, 6 },
-						{I_PROJECTION , C_PROJECTION, 4  },
-						{I_MATERIALS, C_MATERIALS, 4 },
-						{I_LIGHTS, C_LIGHTS, 40 },
-						{I_TEXMATRICES, C_TEXMATRICES, 24 },
-						{I_TRANSFORMMATRICES , C_TRANSFORMMATRICES, 64  },
-						{I_NORMALMATRICES , C_NORMALMATRICES, 32  },
-						{I_POSTTRANSFORMMATRICES, C_POSTTRANSFORMMATRICES, 64 },
-						{I_DEPTHPARAMS, C_DEPTHPARAMS, 1 },
-						};
-
 #pragma pack(1)
 
 struct vertex_shader_uid_data
diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp
index c07286d58f..e603e6e6c4 100644
--- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp
+++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp
@@ -36,6 +36,9 @@ static Matrix33 s_viewInvRotationMatrix;
 static float s_fViewTranslationVector[3];
 static float s_fViewRotation[2];
 
+VertexShaderConstants VertexShaderManager::constants;
+bool VertexShaderManager::dirty;
+
 void UpdateViewport(Matrix44& vpCorrection);
 
 void UpdateViewportWithCorrection()
@@ -43,26 +46,6 @@ void UpdateViewportWithCorrection()
 	UpdateViewport(s_viewportCorrection);
 }
 
-inline void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
-{
-	g_renderer->SetVSConstant4f(const_number, f1, f2, f3, f4);
-}
-
-inline void SetVSConstant4fv(unsigned int const_number, const float *f)
-{
-	g_renderer->SetVSConstant4fv(const_number, f);
-}
-
-inline void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f)
-{
-	g_renderer->SetMultiVSConstant3fv(const_number, count, f);
-}
-
-inline void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f)
-{
-	g_renderer->SetMultiVSConstant4fv(const_number, count, f);
-}
-
 struct ProjectionHack
 {
 	float sign;
@@ -153,6 +136,7 @@ void VertexShaderManager::Init()
 
 	memset(&xfregs, 0, sizeof(xfregs));
 	memset(xfmem, 0, sizeof(xfmem));
+	memset(&constants, 0 , sizeof(constants));
 	ResetView();
 
 	// TODO: should these go inside ResetView()?
@@ -187,21 +171,20 @@ void VertexShaderManager::Dirty()
 	bProjectionChanged = true;
 
 	nMaterialsChanged = 15;
+	
+	dirty = true;
 }
 
 // Syncs the shader constant buffers with xfmem
 // TODO: A cleaner way to control the matrices without making a mess in the parameters field
 void VertexShaderManager::SetConstants()
 {
-	if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO)
-		Dirty();
-
 	if (nTransformMatricesChanged[0] >= 0)
 	{
 		int startn = nTransformMatricesChanged[0] / 4;
 		int endn = (nTransformMatricesChanged[1] + 3) / 4;
-		const float* pstart = (const float*)&xfmem[startn * 4];
-		SetMultiVSConstant4fv(C_TRANSFORMMATRICES + startn, endn - startn, pstart);
+		memcpy(constants.transformmatrices[startn], &xfmem[startn * 4], (endn - startn) * 16);
+		dirty = true;
 		nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1;
 	}
 
@@ -209,8 +192,11 @@ void VertexShaderManager::SetConstants()
 	{
 		int startn = nNormalMatricesChanged[0] / 3;
 		int endn = (nNormalMatricesChanged[1] + 2) / 3;
-		const float *pnstart = (const float*)&xfmem[XFMEM_NORMALMATRICES+3*startn];
-		SetMultiVSConstant3fv(C_NORMALMATRICES + startn, endn - startn, pnstart);
+		for(int i=startn; i<endn; i++)
+		{
+			memcpy(constants.normalmatrices[i], &xfmem[XFMEM_NORMALMATRICES + 3*i], 12);
+		}
+		dirty = true;
 		nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1;
 	}
 
@@ -218,8 +204,8 @@ void VertexShaderManager::SetConstants()
 	{
 		int startn = nPostTransformMatricesChanged[0] / 4;
 		int endn = (nPostTransformMatricesChanged[1] + 3 ) / 4;
-		const float* pstart = (const float*)&xfmem[XFMEM_POSTMATRICES + startn * 4];
-		SetMultiVSConstant4fv(C_POSTTRANSFORMMATRICES + startn, endn - startn, pstart);
+		memcpy(constants.posttransformmatrices[startn], &xfmem[XFMEM_POSTMATRICES + startn * 4], (endn - startn) * 16);
+		dirty = true;
 		nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1;
 	}
 
@@ -233,12 +219,10 @@ void VertexShaderManager::SetConstants()
 		for (int i = istart; i < iend; ++i)
 		{
 			u32 color = *(const u32*)(xfmemptr + 3);
-			float NormalizationCoef = 1 / 255.0f;
-			SetVSConstant4f(C_LIGHTS + 5 * i,
-				((color >> 24) & 0xFF) * NormalizationCoef,
-				((color >> 16) & 0xFF) * NormalizationCoef,
-				((color >> 8)  & 0xFF) * NormalizationCoef,
-				((color)       & 0xFF) * NormalizationCoef);
+			constants.lights[5*i][0] = ((color >> 24) & 0xFF) / 255.0f;
+			constants.lights[5*i][1] = ((color >> 16) & 0xFF) / 255.0f;
+			constants.lights[5*i][2] = ((color >> 8)  & 0xFF) / 255.0f;
+			constants.lights[5*i][3] = ((color)       & 0xFF) / 255.0f;
 			xfmemptr += 4;
 
 			for (int j = 0; j < 4; ++j, xfmemptr += 3)
@@ -249,35 +233,30 @@ void VertexShaderManager::SetConstants()
 					fabs(xfmemptr[2]) < 0.00001f)
 				{
 					// dist attenuation, make sure not equal to 0!!!
-					SetVSConstant4f(C_LIGHTS+5*i+j+1, 0.00001f, xfmemptr[1], xfmemptr[2], 0);
+					constants.lights[5*i+j+1][0] = 0.00001f;
 				}
 				else
-				{
-					SetVSConstant4fv(C_LIGHTS+5*i+j+1, xfmemptr);
-				}
+					constants.lights[5*i+j+1][0] = xfmemptr[0];
+				constants.lights[5*i+j+1][1] = xfmemptr[1];
+				constants.lights[5*i+j+1][2] = xfmemptr[2];
 			}
 		}
+		dirty = true;
 
 		nLightsChanged[0] = nLightsChanged[1] = -1;
 	}
 
 	if (nMaterialsChanged)
 	{
-		float GC_ALIGNED16(material[4]);
-		float NormalizationCoef = 1 / 255.0f;
-
 		for (int i = 0; i < 2; ++i)
 		{
 			if (nMaterialsChanged & (1 << i))
 			{
 				u32 data = *(xfregs.ambColor + i);
-
-				material[0] = ((data >> 24) & 0xFF) * NormalizationCoef;
-				material[1] = ((data >> 16) & 0xFF) * NormalizationCoef;
-				material[2] = ((data >>  8) & 0xFF) * NormalizationCoef;
-				material[3] = ( data        & 0xFF) * NormalizationCoef;
-
-				SetVSConstant4fv(C_MATERIALS + i, material);
+				constants.materials[i][0] = ((data >> 24) & 0xFF) / 255.0f;
+				constants.materials[i][1] = ((data >> 16) & 0xFF) / 255.0f;
+				constants.materials[i][2] = ((data >>  8) & 0xFF) / 255.0f;
+				constants.materials[i][3] = ( data        & 0xFF) / 255.0f;
 			}
 		}
 		
@@ -286,15 +265,13 @@ void VertexShaderManager::SetConstants()
 			if (nMaterialsChanged & (1 << (i + 2)))
 			{
 				u32 data = *(xfregs.matColor + i);
-
-				material[0] = ((data >> 24) & 0xFF) * NormalizationCoef;
-				material[1] = ((data >> 16) & 0xFF) * NormalizationCoef;
-				material[2] = ((data >>  8) & 0xFF) * NormalizationCoef;
-				material[3] = ( data        & 0xFF) * NormalizationCoef;
-
-				SetVSConstant4fv(C_MATERIALS + i + 2, material);
+				constants.materials[i+2][0] = ((data >> 24) & 0xFF) / 255.0f;
+				constants.materials[i+2][1] = ((data >> 16) & 0xFF) / 255.0f;
+				constants.materials[i+2][2] = ((data >>  8) & 0xFF) / 255.0f;
+				constants.materials[i+2][3] = ( data        & 0xFF) / 255.0f;
 			}
 		}
+		dirty = true;
 
 		nMaterialsChanged = 0;
 	}
@@ -306,8 +283,11 @@ void VertexShaderManager::SetConstants()
 		const float *pos = (const float *)xfmem + MatrixIndexA.PosNormalMtxIdx * 4;
 		const float *norm = (const float *)xfmem + XFMEM_NORMALMATRICES + 3 * (MatrixIndexA.PosNormalMtxIdx & 31);
 
-		SetMultiVSConstant4fv(C_POSNORMALMATRIX, 3, pos);
-		SetMultiVSConstant3fv(C_POSNORMALMATRIX + 3, 3, norm);
+		memcpy(constants.posnormalmatrix, pos, 3*16);
+		memcpy(constants.posnormalmatrix[3], norm, 12);
+		memcpy(constants.posnormalmatrix[4], norm+3, 12);
+		memcpy(constants.posnormalmatrix[5], norm+6, 12);
+		dirty = true;
 	}
 
 	if (bTexMatricesChanged[0])
@@ -321,8 +301,9 @@ void VertexShaderManager::SetConstants()
 
 		for (int i = 0; i < 4; ++i)
 		{
-			SetMultiVSConstant4fv(C_TEXMATRICES + 3 * i, 3, fptrs[i]);
+			memcpy(constants.texmatrices[3*i], fptrs[i], 3*16);
 		}
+		dirty = true;
 	}
 
 	if (bTexMatricesChanged[1])
@@ -335,18 +316,19 @@ void VertexShaderManager::SetConstants()
 
 		for (int i = 0; i < 4; ++i)
 		{
-			SetMultiVSConstant4fv(C_TEXMATRICES+3 * i + 12, 3, fptrs[i]);
+			memcpy(constants.texmatrices[3*i+12], fptrs[i], 3*16);
 		}
+		dirty = true;
 	}
 
 	if (bViewportChanged)
 	{
 		bViewportChanged = false;
-		SetVSConstant4f(C_DEPTHPARAMS,
-						xfregs.viewport.farZ / 16777216.0f,
-						xfregs.viewport.zRange / 16777216.0f,
-						-1.f / (float)g_renderer->EFBToScaledX((int)ceil(2.0f * xfregs.viewport.wd)),
-						1.f / (float)g_renderer->EFBToScaledY((int)ceil(-2.0f * xfregs.viewport.ht)));
+		constants.depthparams[0] = xfregs.viewport.farZ / 16777216.0f;
+		constants.depthparams[1] = xfregs.viewport.zRange / 16777216.0f;
+		constants.depthparams[2] = -1.f / g_renderer->EFBToScaledX(ceilf(2.0f * xfregs.viewport.wd));
+		constants.depthparams[3] = 1.f / g_renderer->EFBToScaledY(ceilf(-2.0f * xfregs.viewport.ht));
+		dirty = true;
 		// This is so implementation-dependent that we can't have it here.
 		UpdateViewport(s_viewportCorrection);
 		bProjectionChanged = true;
@@ -475,8 +457,7 @@ void VertexShaderManager::SetConstants()
 			Matrix44::Set(mtxB, g_fProjectionMatrix);
 			Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view
 			Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA
-
-			SetMultiVSConstant4fv(C_PROJECTION, 4, mtxB.data);
+			memcpy(constants.projection, mtxB.data, 4*16);
 		}
 		else
 		{
@@ -485,8 +466,9 @@ void VertexShaderManager::SetConstants()
 
 			Matrix44 correctedMtx;
 			Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx);
-			SetMultiVSConstant4fv(C_PROJECTION, 4, correctedMtx.data);
+			memcpy(constants.projection, correctedMtx.data, 4*16);
 		}
+		dirty = true;
 	}
 }
 
@@ -614,7 +596,7 @@ void VertexShaderManager::SetProjectionChanged()
 	bProjectionChanged = true;
 }
 
-void VertexShaderManager::SetMaterialColorChanged(int index)
+void VertexShaderManager::SetMaterialColorChanged(int index, u32 color)
 {
 	nMaterialsChanged  |= (1 << index);
 }
@@ -669,6 +651,8 @@ void VertexShaderManager::DoState(PointerWrap &p)
 	p.Do(s_viewInvRotationMatrix);
 	p.Do(s_fViewTranslationVector);
 	p.Do(s_fViewRotation);
+	p.Do(constants);
+	p.Do(dirty);
 
 	if (p.GetMode() == PointerWrap::MODE_READ)
 	{
diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.h b/Source/Core/VideoCommon/Src/VertexShaderManager.h
index b4c5d3907c..60e23902f1 100644
--- a/Source/Core/VideoCommon/Src/VertexShaderManager.h
+++ b/Source/Core/VideoCommon/Src/VertexShaderManager.h
@@ -6,6 +6,7 @@
 #define _VERTEXSHADERMANAGER_H
 
 #include "VertexShaderGen.h"
+#include "ConstantManager.h"
 
 class PointerWrap;
 
@@ -30,11 +31,14 @@ public:
 	static void SetTexMatrixChangedB(u32 value);
 	static void SetViewportChanged();
 	static void SetProjectionChanged();
-	static void SetMaterialColorChanged(int index);
+	static void SetMaterialColorChanged(int index, u32 color);
 
 	static void TranslateView(float x, float y, float z = 0.0f);
 	static void RotateView(float x, float y);
 	static void ResetView();
+	
+	static VertexShaderConstants constants;
+	static bool dirty;
 };
 
 #endif // _VERTEXSHADERMANAGER_H
diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h
index 175bd8a5b0..ef36b1fed6 100644
--- a/Source/Core/VideoCommon/Src/VideoCommon.h
+++ b/Source/Core/VideoCommon/Src/VideoCommon.h
@@ -132,11 +132,5 @@ inline unsigned int GetPow2(unsigned int val)
 		++ret;
 	return ret;
 }
-struct s_svar
-{
-	const char *name;
-	const unsigned int reg;
-	const unsigned int size;
-};
 
 #endif  // _VIDEOCOMMON_H
diff --git a/Source/Core/VideoCommon/Src/XFStructs.cpp b/Source/Core/VideoCommon/Src/XFStructs.cpp
index a2f2097e07..7d806fcabe 100644
--- a/Source/Core/VideoCommon/Src/XFStructs.cpp
+++ b/Source/Core/VideoCommon/Src/XFStructs.cpp
@@ -60,8 +60,8 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 				if (xfregs.ambColor[chan] != newValue) 
 				{
 					VertexManager::Flush();
-					VertexShaderManager::SetMaterialColorChanged(chan);
-					PixelShaderManager::SetMaterialColorChanged(chan);
+					VertexShaderManager::SetMaterialColorChanged(chan, newValue);
+					PixelShaderManager::SetMaterialColorChanged(chan, newValue);
 				}
 				break;
 			}
@@ -73,8 +73,8 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 				if (xfregs.matColor[chan] != newValue)
 				{
 					VertexManager::Flush();
-					VertexShaderManager::SetMaterialColorChanged(chan + 2);
-					PixelShaderManager::SetMaterialColorChanged(chan + 2);
+					VertexShaderManager::SetMaterialColorChanged(chan + 2, newValue);
+					PixelShaderManager::SetMaterialColorChanged(chan + 2, newValue);
 				}
 				break;
 			}