Move VertexShaderManager too.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1688 8ced0084-cf51-0410-be5f-012b33b47a6e

6 files changed, 517 insertions, 3 deletions

diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
index 0b9f4ab7c9..ba2c528e11 100644
--- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
+++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp
@@ -23,9 +23,7 @@
 #include "Statistics.h"
 
 #include "PixelShaderManager.h"
-
-// TODO: move logging to VideoCommon. Until then -
-#define PRIM_LOG(x, ...)
+#include "VideoCommon.h"
 
 static int s_nColorsChanged[2]; // 0 - regular colors, 1 - k colors
 static int s_nIndTexMtxChanged = 0;
diff --git a/Source/Core/VideoCommon/Src/SConscript b/Source/Core/VideoCommon/Src/SConscript
index cc19c260eb..0b8c44cbc4 100644
--- a/Source/Core/VideoCommon/Src/SConscript
+++ b/Source/Core/VideoCommon/Src/SConscript
@@ -13,6 +13,7 @@ files = [
 	"PixelShader.cpp",
 	"PixelShaderManager.cpp",
 	"VertexShader.cpp",
+	"VertexShaderManager.cpp",
 	"ImageWrite.cpp",
 	"Statistics.cpp",
 	"Fifo.cpp",
diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp
new file mode 100644
index 0000000000..48e9128298
--- /dev/null
+++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp
@@ -0,0 +1,434 @@
+// Copyright (C) 2003-2008 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/
+
+#include "Common.h"
+#include "Profiler.h"
+
+#include <cmath>
+
+#include "Statistics.h"
+
+#include "VertexShader.h"
+#include "VertexShaderManager.h"
+#include "BPMemory.h"
+#include "CPMemory.h"
+#include "XFMemory.h"
+#include "VideoCommon.h"
+
+// Temporary ugly declaration.
+namespace VertexManager
+{
+	void Flush();
+}
+
+static float s_fMaterials[16];
+
+// track changes
+static bool bTexMatricesChanged[2], bPosNormalMatrixChanged, bProjectionChanged, bViewportChanged;
+static int nMaterialsChanged;
+static int nTransformMatricesChanged[2]; // min,max
+static int nNormalMatricesChanged[2]; // min,max
+static int nPostTransformMatricesChanged[2]; // min,max
+static int nLightsChanged[2]; // min,max
+
+void UpdateViewport();
+
+void VertexShaderManager::Init()
+{
+    nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1;
+    nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1;
+    nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1;
+    nLightsChanged[0] = nLightsChanged[1] = -1;
+    bTexMatricesChanged[0] = bTexMatricesChanged[1] = false;
+    bPosNormalMatrixChanged = bProjectionChanged = bViewportChanged = false;
+    nMaterialsChanged = 0;
+
+    memset(&xfregs, 0, sizeof(xfregs));
+    memset(xfmem, 0, sizeof(xfmem));
+}
+
+void VertexShaderManager::Shutdown()
+{
+
+}
+
+// =======================================================================================
+// Syncs the shader constant buffers with xfmem
+// ----------------
+void VertexShaderManager::SetConstants(bool proj_hax_1, bool proj_hax_2)
+{
+    //nTransformMatricesChanged[0] = 0; nTransformMatricesChanged[1] = 256;
+    //nNormalMatricesChanged[0] = 0; nNormalMatricesChanged[1] = 96;
+    //nPostTransformMatricesChanged[0] = 0; nPostTransformMatricesChanged[1] = 256;
+    //nLightsChanged[0] = 0; nLightsChanged[1] = 0x80;
+    //bPosNormalMatrixChanged = true;
+    //bTexMatricesChanged[0] = bTexMatricesChanged[1] = true;
+    //bProjectionChanged = true;
+//    bPosNormalMatrixChanged = bTexMatricesChanged[0] = bTexMatricesChanged[1] = true;
+//    nMaterialsChanged = 15;
+
+    if (nTransformMatricesChanged[0] >= 0) {
+        int startn = nTransformMatricesChanged[0]/4;
+        int endn = (nTransformMatricesChanged[1]+3)/4;
+        const float* pstart = (const float*)&xfmem[startn*4];
+        for(int i = startn; i < endn; ++i, pstart += 4)
+            SetVSConstant4fv(C_TRANSFORMMATRICES+i, pstart);
+        nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1;
+    }
+    if (nNormalMatricesChanged[0] >= 0) {
+        int startn = nNormalMatricesChanged[0]/3;
+        int endn = (nNormalMatricesChanged[1]+2)/3;
+        const float* pnstart = (const float*)&xfmem[XFMEM_NORMALMATRICES+3*startn];
+
+        for(int i = startn; i < endn; ++i, pnstart += 3)
+            SetVSConstant4fv(C_NORMALMATRICES+i, pnstart);
+
+        nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1;
+    }
+
+    if (nPostTransformMatricesChanged[0] >= 0) {
+        int startn = nPostTransformMatricesChanged[0]/4;
+        int endn = (nPostTransformMatricesChanged[1]+3)/4;
+        const float* pstart = (const float*)&xfmem[XFMEM_POSTMATRICES + startn*4];
+        for(int i = startn; i < endn; ++i, pstart += 4)
+            SetVSConstant4fv(C_POSTTRANSFORMMATRICES + i, pstart);
+    }
+
+    if (nLightsChanged[0] >= 0) {
+        // lights don't have a 1 to 1 mapping, the color component needs to be converted to 4 floats
+        int istart = nLightsChanged[0] / 0x10;
+        int iend = (nLightsChanged[1] + 15) / 0x10;
+        const float* xfmemptr = (const float*)&xfmem[0x10*istart + XFMEM_LIGHTS];
+
+        for (int i = istart; i < iend; ++i) {
+            u32 color = *(const u32*)(xfmemptr + 3);
+            SetVSConstant4f(C_LIGHTS + 5*i,
+                ((color >> 24) & 0xFF)/255.0f,
+				((color >> 16) & 0xFF)/255.0f,
+				((color >> 8)  & 0xFF)/255.0f,
+				((color)       & 0xFF)/255.0f);
+            xfmemptr += 4;
+            for (int j = 0; j < 4; ++j, xfmemptr += 3) {
+				if (j == 1 &&
+					fabs(xfmemptr[0]) < 0.00001f &&
+					fabs(xfmemptr[1]) < 0.00001f &&
+					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);
+                }
+                else
+                    SetVSConstant4fv(C_LIGHTS+5*i+j+1, xfmemptr);
+            }
+        }
+
+        nLightsChanged[0] = nLightsChanged[1] = -1;
+    }
+
+    if (nMaterialsChanged) {
+        for (int i = 0; i < 4; ++i) {
+            if (nMaterialsChanged & (1 << i))
+                SetVSConstant4fv(C_MATERIALS + i, &s_fMaterials[4*i]);
+        }
+        nMaterialsChanged = 0;
+    }
+
+    if (bPosNormalMatrixChanged) {
+        bPosNormalMatrixChanged = false;
+
+        float* pos = (float*)xfmem + MatrixIndexA.PosNormalMtxIdx * 4;
+        float* norm = (float*)xfmem + XFMEM_NORMALMATRICES + 3 * (MatrixIndexA.PosNormalMtxIdx & 31);
+
+        SetVSConstant4fv(C_POSNORMALMATRIX, pos);
+        SetVSConstant4fv(C_POSNORMALMATRIX+1, pos+4);
+        SetVSConstant4fv(C_POSNORMALMATRIX+2, pos+8);
+        SetVSConstant4fv(C_POSNORMALMATRIX+3, norm);
+        SetVSConstant4fv(C_POSNORMALMATRIX+4, norm+3);
+        SetVSConstant4fv(C_POSNORMALMATRIX+5, norm+6);
+    }
+
+    if (bTexMatricesChanged[0]) {
+        bTexMatricesChanged[0] = false;
+        float* fptrs[] = {
+			(float*)xfmem + MatrixIndexA.Tex0MtxIdx * 4, (float*)xfmem + MatrixIndexA.Tex1MtxIdx * 4,
+            (float*)xfmem + MatrixIndexA.Tex2MtxIdx * 4, (float*)xfmem + MatrixIndexA.Tex3MtxIdx * 4
+		};
+
+        for (int i = 0; i < 4; ++i) {
+            SetVSConstant4fv(C_TEXMATRICES+3*i, fptrs[i]);
+            SetVSConstant4fv(C_TEXMATRICES+3*i+1, fptrs[i]+4);
+            SetVSConstant4fv(C_TEXMATRICES+3*i+2, fptrs[i]+8);
+        }
+    }
+
+    if (bTexMatricesChanged[1]) {
+        bTexMatricesChanged[1] = false;
+
+        float* fptrs[] = {(float*)xfmem + MatrixIndexB.Tex4MtxIdx * 4, (float*)xfmem + MatrixIndexB.Tex5MtxIdx * 4,
+            (float*)xfmem + MatrixIndexB.Tex6MtxIdx * 4, (float*)xfmem + MatrixIndexB.Tex7MtxIdx * 4 };
+
+        for (int i = 0; i < 4; ++i) {
+            SetVSConstant4fv(C_TEXMATRICES+3*i+12, fptrs[i]);
+            SetVSConstant4fv(C_TEXMATRICES+3*i+12+1, fptrs[i]+4);
+            SetVSConstant4fv(C_TEXMATRICES+3*i+12+2, fptrs[i]+8);
+        }
+    }
+
+    if (bViewportChanged) {
+        bViewportChanged = false;
+
+		// This is so implementation-dependent that we can't have it here.
+		UpdateViewport();
+    }
+
+    if (bProjectionChanged) {
+        bProjectionChanged = false;
+		static float GC_ALIGNED16(g_fProjectionMatrix[16]);
+
+        if (xfregs.rawProjection[6] == 0) {
+            g_fProjectionMatrix[0] = xfregs.rawProjection[0];
+            g_fProjectionMatrix[1] = 0.0f;
+            g_fProjectionMatrix[2] = xfregs.rawProjection[1];
+            g_fProjectionMatrix[3] = 0;
+
+            g_fProjectionMatrix[4] = 0.0f;
+            g_fProjectionMatrix[5] = xfregs.rawProjection[2];
+            g_fProjectionMatrix[6] = xfregs.rawProjection[3];
+            g_fProjectionMatrix[7] = 0;
+
+            g_fProjectionMatrix[8] = 0.0f;
+            g_fProjectionMatrix[9] = 0.0f;
+            g_fProjectionMatrix[10] = xfregs.rawProjection[4];
+
+			//---------Projection[11]---------
+			// No hacks
+			if ((!proj_hax_1 && !proj_hax_2) || (proj_hax_1 && proj_hax_2))
+				g_fProjectionMatrix[11] = -(0.0f - xfregs.rawProjection[5]);
+
+			// Before R945 Hack
+			if (proj_hax_1 && !proj_hax_2)
+				g_fProjectionMatrix[11] = -(1.0f -  xfregs.rawProjection[5]); 
+
+			// R844 Hack
+			if (!proj_hax_1 && proj_hax_2)
+				g_fProjectionMatrix[11] =  xfregs.rawProjection[5];
+			//--------------------------------
+ 			
+            g_fProjectionMatrix[12] = 0.0f;
+            g_fProjectionMatrix[13] = 0.0f;
+			// donkopunchstania: GC GPU rounds differently?
+			// -(1 + epsilon) so objects are clipped as they are on the real HW
+            g_fProjectionMatrix[14] = -1.00000011921f;
+            g_fProjectionMatrix[15] = 0.0f;
+        }
+        else {
+            g_fProjectionMatrix[0] = xfregs.rawProjection[0];
+            g_fProjectionMatrix[1] = 0.0f;
+            g_fProjectionMatrix[2] = 0.0f;
+            g_fProjectionMatrix[3] = xfregs.rawProjection[1];
+
+            g_fProjectionMatrix[4] = 0.0f;
+            g_fProjectionMatrix[5] = xfregs.rawProjection[2];
+            g_fProjectionMatrix[6] = 0.0f;
+            g_fProjectionMatrix[7] = xfregs.rawProjection[3];
+
+            g_fProjectionMatrix[8] = 0.0f;
+            g_fProjectionMatrix[9] = 0.0f;
+            g_fProjectionMatrix[10] = xfregs.rawProjection[4];
+			
+			//---------Projection[11]---------
+			// No hacks
+			if ((!proj_hax_1 && !proj_hax_2) || (proj_hax_1 && proj_hax_2))
+				g_fProjectionMatrix[11] = -(-1.0f - xfregs.rawProjection[5]);
+
+			// Before R945 Hack
+			if (proj_hax_1 && !proj_hax_2)
+				g_fProjectionMatrix[11] = -(0.0f - xfregs.rawProjection[5]);
+
+			// R844 Hack
+			if (!proj_hax_1 && proj_hax_2)
+				g_fProjectionMatrix[11] = -xfregs.rawProjection[5];
+
+			//--------------------------------
+
+            g_fProjectionMatrix[12] = 0;
+            g_fProjectionMatrix[13] = 0;
+            g_fProjectionMatrix[14] = 0.0f;
+            g_fProjectionMatrix[15] = 1.0f;
+        }
+
+        PRIM_LOG("Projection: %f %f %f %f %f %f\n", xfregs.rawProjection[0], xfregs.rawProjection[1], xfregs.rawProjection[2], xfregs.rawProjection[3], xfregs.rawProjection[4], xfregs.rawProjection[5]);
+        SetVSConstant4fv(C_PROJECTION,   &g_fProjectionMatrix[0]);
+        SetVSConstant4fv(C_PROJECTION+1, &g_fProjectionMatrix[4]);
+        SetVSConstant4fv(C_PROJECTION+2, &g_fProjectionMatrix[8]);
+        SetVSConstant4fv(C_PROJECTION+3, &g_fProjectionMatrix[12]);
+    }
+}
+
+void VertexShaderManager::InvalidateXFRange(int start, int end)
+{
+    if (((u32)start >= (u32)MatrixIndexA.PosNormalMtxIdx*4 &&
+		 (u32)start <  (u32)MatrixIndexA.PosNormalMtxIdx*4 + 12) ||
+        ((u32)start >= XFMEM_NORMALMATRICES + ((u32)MatrixIndexA.PosNormalMtxIdx & 31)*3 &&
+		 (u32)start <  XFMEM_NORMALMATRICES + ((u32)MatrixIndexA.PosNormalMtxIdx & 31)*3 + 9)) {
+        bPosNormalMatrixChanged = true;
+    }
+
+    if (((u32)start >= (u32)MatrixIndexA.Tex0MtxIdx*4 && (u32)start < (u32)MatrixIndexA.Tex0MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexA.Tex1MtxIdx*4 && (u32)start < (u32)MatrixIndexA.Tex1MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexA.Tex2MtxIdx*4 && (u32)start < (u32)MatrixIndexA.Tex2MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexA.Tex3MtxIdx*4 && (u32)start < (u32)MatrixIndexA.Tex3MtxIdx*4+12)) {
+        bTexMatricesChanged[0] = true;
+    }
+
+    if (((u32)start >= (u32)MatrixIndexB.Tex4MtxIdx*4 && (u32)start < (u32)MatrixIndexB.Tex4MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexB.Tex5MtxIdx*4 && (u32)start < (u32)MatrixIndexB.Tex5MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexB.Tex6MtxIdx*4 && (u32)start < (u32)MatrixIndexB.Tex6MtxIdx*4+12) ||
+        ((u32)start >= (u32)MatrixIndexB.Tex7MtxIdx*4 && (u32)start < (u32)MatrixIndexB.Tex7MtxIdx*4+12)) {
+        bTexMatricesChanged[1] = true;
+    }
+
+    if (start < XFMEM_POSMATRICES_END) {
+        if (nTransformMatricesChanged[0] == -1) {
+            nTransformMatricesChanged[0] = start;
+            nTransformMatricesChanged[1] = end>XFMEM_POSMATRICES_END?XFMEM_POSMATRICES_END:end;
+        }
+        else {
+            if (nTransformMatricesChanged[0] > start) nTransformMatricesChanged[0] = start;
+            if (nTransformMatricesChanged[1] < end) nTransformMatricesChanged[1] = end>XFMEM_POSMATRICES_END?XFMEM_POSMATRICES_END:end;
+        }
+    }
+
+    if (start < XFMEM_NORMALMATRICES_END && end > XFMEM_NORMALMATRICES) {
+        int _start = start < XFMEM_NORMALMATRICES ? 0 : start-XFMEM_NORMALMATRICES;
+        int _end = end < XFMEM_NORMALMATRICES_END ? end-XFMEM_NORMALMATRICES : XFMEM_NORMALMATRICES_END-XFMEM_NORMALMATRICES;
+
+        if (nNormalMatricesChanged[0] == -1 ) {
+            nNormalMatricesChanged[0] = _start;
+            nNormalMatricesChanged[1] = _end;
+        }
+        else {
+            if (nNormalMatricesChanged[0] > _start) nNormalMatricesChanged[0] = _start;
+            if (nNormalMatricesChanged[1] < _end) nNormalMatricesChanged[1] = _end;
+        }
+    }
+
+    if (start < XFMEM_POSTMATRICES_END && end > XFMEM_POSTMATRICES) {
+        int _start = start < XFMEM_POSTMATRICES ? XFMEM_POSTMATRICES : start-XFMEM_POSTMATRICES;
+        int _end = end < XFMEM_POSTMATRICES_END ? end-XFMEM_POSTMATRICES : XFMEM_POSTMATRICES_END-XFMEM_POSTMATRICES;
+
+        if (nPostTransformMatricesChanged[0] == -1 ) {
+            nPostTransformMatricesChanged[0] = _start;
+            nPostTransformMatricesChanged[1] = _end;
+        }
+        else {
+            if (nPostTransformMatricesChanged[0] > _start) nPostTransformMatricesChanged[0] = _start;
+            if (nPostTransformMatricesChanged[1] < _end) nPostTransformMatricesChanged[1] = _end;
+        }
+    }
+
+    if (start < XFMEM_LIGHTS_END && end > XFMEM_LIGHTS) {
+        int _start = start < XFMEM_LIGHTS ? XFMEM_LIGHTS : start-XFMEM_LIGHTS;
+        int _end = end < XFMEM_LIGHTS_END ? end-XFMEM_LIGHTS : XFMEM_LIGHTS_END-XFMEM_LIGHTS;
+
+        if (nLightsChanged[0] == -1 ) {
+            nLightsChanged[0] = _start;
+            nLightsChanged[1] = _end;
+        }
+        else {
+            if (nLightsChanged[0] > _start) nLightsChanged[0] = _start;
+            if (nLightsChanged[1] < _end)   nLightsChanged[1] = _end;
+        }
+    }
+}
+
+void VertexShaderManager::SetTexMatrixChangedA(u32 Value)
+{
+    if (MatrixIndexA.Hex != Value) {
+        VertexManager::Flush();
+        if (MatrixIndexA.PosNormalMtxIdx != (Value&0x3f))
+            bPosNormalMatrixChanged = true;
+        bTexMatricesChanged[0] = true;
+        MatrixIndexA.Hex = Value;
+    }
+}
+
+void VertexShaderManager::SetTexMatrixChangedB(u32 Value)
+{
+    if (MatrixIndexB.Hex != Value) {
+        VertexManager::Flush();
+        bTexMatricesChanged[1] = true;
+        MatrixIndexB.Hex = Value;
+    }
+}
+
+void VertexShaderManager::SetViewport(float* _Viewport)
+{
+    // Workaround for paper mario, yep this is bizarre.
+    for (size_t i = 0; i < ARRAYSIZE(xfregs.rawViewport); ++i) {
+        if (*(u32*)(_Viewport + i) == 0x7f800000)  // invalid fp number
+            return;
+    }
+    memcpy(xfregs.rawViewport, _Viewport, sizeof(xfregs.rawViewport));
+    bViewportChanged = true;
+}
+
+void VertexShaderManager::SetViewportChanged()
+{
+    bViewportChanged = true;
+}
+
+void VertexShaderManager::SetProjection(float* _pProjection, int constantIndex)
+{
+    memcpy(xfregs.rawProjection, _pProjection, sizeof(xfregs.rawProjection));
+    bProjectionChanged = true;
+}
+
+void VertexShaderManager::SetMaterialColor(int index, u32 data)
+{
+	// TODO: collapse
+	switch (index)
+	{
+	case 0:
+        nMaterialsChanged |= 1;
+        s_fMaterials[0] = ((data>>24)&0xFF)/255.0f;
+        s_fMaterials[1] = ((data>>16)&0xFF)/255.0f;
+        s_fMaterials[2] = ((data>>8)&0xFF)/255.0f;
+        s_fMaterials[3] = ((data)&0xFF)/255.0f;
+		break;
+	case 1:
+        nMaterialsChanged |= 2;
+        s_fMaterials[4] = ((data>>24)&0xFF)/255.0f;
+        s_fMaterials[5] = ((data>>16)&0xFF)/255.0f;
+        s_fMaterials[6] = ((data>>8)&0xFF)/255.0f;
+        s_fMaterials[7] = ((data)&0xFF)/255.0f;
+		break;
+	case 2:
+        nMaterialsChanged |= 4;
+        s_fMaterials[8] = ((data>>24)&0xFF)/255.0f;
+        s_fMaterials[9] = ((data>>16)&0xFF)/255.0f;
+        s_fMaterials[10] = ((data>>8)&0xFF)/255.0f;
+        s_fMaterials[11] = ((data)&0xFF)/255.0f;
+		break;
+	case 3:
+        nMaterialsChanged |= 8;
+        s_fMaterials[12] = ((data>>24)&0xFF)/255.0f;
+        s_fMaterials[13] = ((data>>16)&0xFF)/255.0f;
+        s_fMaterials[14] = ((data>>8)&0xFF)/255.0f;
+        s_fMaterials[15] = ((data)&0xFF)/255.0f;
+		break;
+	}
+}
\ No newline at end of file
diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.h b/Source/Core/VideoCommon/Src/VertexShaderManager.h
new file mode 100644
index 0000000000..10d308a66d
--- /dev/null
+++ b/Source/Core/VideoCommon/Src/VertexShaderManager.h
@@ -0,0 +1,45 @@
+// Copyright (C) 2003-2008 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 _VERTEXSHADERMANAGER_H
+#define _VERTEXSHADERMANAGER_H
+
+#include "VertexShader.h"
+
+// The non-API dependent parts.
+class VertexShaderManager
+{
+public:
+    static void Init();
+    static void Shutdown();
+
+    // constant management
+	static void SetConstants(bool proj_hax_1, bool proj_hax_2);
+
+    static void SetViewport(float* _Viewport);
+    static void SetViewportChanged();
+    static void SetProjection(float* _pProjection, int constantIndex = -1);
+    static void InvalidateXFRange(int start, int end);
+    static void SetTexMatrixChangedA(u32 Value);
+    static void SetTexMatrixChangedB(u32 Value);
+	static void SetMaterialColor(int index, u32 data);
+};
+
+void SetVSConstant4f(int const_number, float f1, float f2, float f3, float f4);
+void SetVSConstant4fv(int const_number, const float *f);
+
+#endif
diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h
index 1f891631f3..cea4bcaf00 100644
--- a/Source/Core/VideoCommon/Src/VideoCommon.h
+++ b/Source/Core/VideoCommon/Src/VideoCommon.h
@@ -21,6 +21,17 @@
 #include "Common.h"

 #include "pluginspecs_video.h"

 

+enum {

+	EFB_WIDTH = 640,

+	EFB_HEIGHT = 528,

+};

+

+enum {

+	XFB_WIDTH = 640,

+	XFB_HEIGHT = 480, // 528 is max height ... ? or 538?

+	// TODO: figure out what to do with PAL

+};

+

 extern SVideoInitialize g_VideoInitialize;

 

 void DebugLog(const char* _fmt, ...);

@@ -57,4 +68,21 @@ struct TRectangle
 	int left, top, right, bottom;

 };

 

+void DebugLog(const char* _fmt, ...);

+void __Log(const char *format, ...);

+void __Log(int type, const char *format, ...);

+void HandleGLError();

+

+#define ERROR_LOG __Log

+

+#if defined(_DEBUG) || defined(DEBUGFAST)

+#define INFO_LOG if( g_Config.iLog & CONF_LOG ) __Log

+#define PRIM_LOG if( g_Config.iLog & CONF_PRIMLOG ) __Log

+#define DEBUG_LOG __Log

+#else

+#define INFO_LOG(...)

+#define PRIM_LOG(...)

+#define DEBUG_LOG(...)

+#endif

+

 #endif  // _VIDEOCOMMON_H

diff --git a/Source/Core/VideoCommon/VideoCommon.vcproj b/Source/Core/VideoCommon/VideoCommon.vcproj
index 08a68aec10..c5471a6164 100644
--- a/Source/Core/VideoCommon/VideoCommon.vcproj
+++ b/Source/Core/VideoCommon/VideoCommon.vcproj
@@ -548,6 +548,14 @@
 			>

 		</File>

 		<File

+			RelativePath=".\Src\VertexShaderManager.cpp"

+			>

+		</File>

+		<File

+			RelativePath=".\Src\VertexShaderManager.h"

+			>

+		</File>

+		<File

 			RelativePath=".\Src\VideoCommon.h"

 			>

 		</File>