Lots of code and warning cleanup. OGL/D3D: Moved to a shared config class in VideoCommon. This lets VideoCommon code read the config without ugly hacks. Fixed various config race conditions by keeping a copy (g_ActiveConfig) of the g_Config struct which is updated once per frame.

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

8 files changed, 433 insertions, 5 deletions

diff --git a/Source/Core/VideoCommon/Src/Config.cpp b/Source/Core/VideoCommon/Src/Config.cpp
new file mode 100644
index 0000000000..0168715263
--- /dev/null
+++ b/Source/Core/VideoCommon/Src/Config.cpp
@@ -0,0 +1,265 @@
+// 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/
+
+#include <cmath>
+
+#include "Common.h"
+#include "IniFile.h"
+#include "Config.h"
+#include "VideoCommon.h"
+
+Config g_Config;
+Config g_ActiveConfig;
+
+void UpdateActiveConfig() 
+{
+	g_ActiveConfig = g_Config;
+}
+
+Config::Config()
+{
+	bRunning = false;
+}
+
+void Config::Load(const char *ini_file)
+{
+    std::string temp;
+    IniFile iniFile;
+    iniFile.Load(ini_file);
+
+	// get resolution
+    iniFile.Get("Hardware", "WindowedRes", &temp, "640x480");
+    strncpy(cInternalRes, temp.c_str(), 16);
+	iniFile.Get("Hardware", "FullscreenRes", &temp, "640x480");
+    strncpy(cFSResolution, temp.c_str(), 16);
+    
+    iniFile.Get("Hardware", "Fullscreen", &bFullscreen, 0); // Hardware
+    iniFile.Get("Hardware", "VSync", &bVSync, 0); // Hardware
+    iniFile.Get("Hardware", "RenderToMainframe", &RenderToMainframe, false);
+    iniFile.Get("Settings", "StretchToFit", &bNativeResolution, true);
+	iniFile.Get("Settings", "2xResolution", &b2xResolution, false);
+	iniFile.Get("Settings", "wideScreenHack", &bWidescreenHack, false);
+	iniFile.Get("Settings", "KeepAR_4_3", &bKeepAR43, false);
+	iniFile.Get("Settings", "KeepAR_16_9", &bKeepAR169, false);
+	iniFile.Get("Settings", "Crop", &bCrop, false);
+    iniFile.Get("Settings", "HideCursor", &bHideCursor, false);
+    iniFile.Get("Settings", "UseXFB", &bUseXFB, 0);
+    iniFile.Get("Settings", "AutoScale", &bAutoScale, true);
+    
+    iniFile.Get("Settings", "SafeTextureCache", &bSafeTextureCache, false); // Settings
+    iniFile.Get("Settings", "ShowFPS", &bShowFPS, false); // Settings
+    iniFile.Get("Settings", "OverlayStats", &bOverlayStats, false);
+	iniFile.Get("Settings", "OverlayProjStats", &bOverlayProjStats, false);
+	iniFile.Get("Settings", "ShowEFBCopyRegions", &bShowEFBCopyRegions, false);
+    iniFile.Get("Settings", "DLOptimize", &iCompileDLsLevel, 0);
+    iniFile.Get("Settings", "DumpTextures", &bDumpTextures, 0);
+    iniFile.Get("Settings", "HiresTextures", &bHiresTextures, 0);
+	iniFile.Get("Settings", "DumpEFBTarget", &bDumpEFBTarget, 0);
+	iniFile.Get("Settings", "DumpFrames", &bDumpFrames, 0);
+    iniFile.Get("Settings", "FreeLook", &bFreeLook, 0);
+    iniFile.Get("Settings", "ShowShaderErrors", &bShowShaderErrors, 0);
+    iniFile.Get("Settings", "MSAA", &iMultisampleMode, 0);
+    iniFile.Get("Settings", "DstAlphaPass", &bDstAlphaPass, false);
+    
+    iniFile.Get("Settings", "TexFmtOverlayEnable", &bTexFmtOverlayEnable, 0);
+    iniFile.Get("Settings", "TexFmtOverlayCenter", &bTexFmtOverlayCenter, 0);
+    iniFile.Get("Settings", "WireFrame", &bWireFrame, 0);
+    iniFile.Get("Settings", "DisableLighting", &bDisableLighting, 0);
+    iniFile.Get("Settings", "DisableTexturing", &bDisableTexturing, 0);
+	iniFile.Get("Settings", "DisableFog", &bDisableFog, 0);
+    
+    iniFile.Get("Enhancements", "ForceFiltering", &bForceFiltering, 0);
+    iniFile.Get("Enhancements", "MaxAnisotropy", &iMaxAnisotropy, 3);  // NOTE - this is x in (1 << x)
+	iniFile.Get("Enhancements", "PostProcessingShader", &sPostProcessingShader, "");
+    
+    iniFile.Get("Hacks", "EFBCopyDisable", &bEFBCopyDisable, 0);
+    iniFile.Get("Hacks", "EFBCopyDisableHotKey", &bEFBCopyDisableHotKey, 0);
+	iniFile.Get("Hacks", "EFBToTextureEnable", &bCopyEFBToRAM, 0);
+	iniFile.Get("Hacks", "ProjectionHack", &iPhackvalue, 0);
+
+	iniFile.Get("Hardware", "Adapter", &iAdapter, 0);
+	if (iAdapter == -1) 
+		iAdapter = 0;
+	iniFile.Get("Hardware", "WindowedRes", &iWindowedRes, 0);
+	iniFile.Get("Hardware", "VSync", &bVsync, 0);
+	iniFile.Get("Hardware", "FullscreenRes", &iFSResolution, 0);
+
+	// Load common settings
+	iniFile.Load(CONFIG_FILE);
+	bool bTmp;
+	iniFile.Get("Interface", "UsePanicHandlers", &bTmp, true);
+	SetEnableAlert(bTmp);
+}
+
+void Config::GameIniLoad(IniFile *iniFile)
+{
+	if (! iniFile) 
+		return;
+	
+	if (iniFile->Exists("Video", "ForceFiltering"))
+		iniFile->Get("Video", "ForceFiltering", &bForceFiltering, 0);
+
+	if (iniFile->Exists("Video", "MaxAnisotropy"))
+		iniFile->Get("Video", "MaxAnisotropy", &iMaxAnisotropy, 3);  // NOTE - this is x in (1 << x)
+    
+	if (iniFile->Exists("Video", "EFBCopyDisable"))
+		iniFile->Get("Video", "EFBCopyDisable", &bEFBCopyDisable, 0);
+
+	if (iniFile->Exists("Video", "EFBCopyDisableHotKey"))
+		iniFile->Get("Video", "EFBCopyDisableHotKey", &bEFBCopyDisableHotKey, 0);
+
+	if (iniFile->Exists("Video", "EFBToRAMEnable"))
+		iniFile->Get("Video", "EFBToRAMEnable", &bCopyEFBToRAM, 0);
+
+	if (iniFile->Exists("Video", "SafeTextureCache"))
+		iniFile->Get("Video", "SafeTextureCache", &bSafeTextureCache, false); 
+
+	if (iniFile->Exists("Video", "MSAA"))
+		iniFile->Get("Video", "MSAA", &iMultisampleMode, 0);
+
+	if (iniFile->Exists("Video", "DstAlphaPass"))
+		iniFile->Get("Video", "DstAlphaPass", &bDstAlphaPass, false);
+	
+	if (iniFile->Exists("Video", "UseXFB"))
+		iniFile->Get("Video", "UseXFB", &bUseXFB, 0);
+
+	if (iniFile->Exists("Video", "ProjectionHack"))
+		iniFile->Get("Video", "ProjectionHack", &iPhackvalue, 0);
+}
+
+void Config::Save(const char *ini_file)
+{
+    IniFile iniFile;
+    iniFile.Load(ini_file);
+    iniFile.Set("Hardware", "WindowedRes", cInternalRes);
+    iniFile.Set("Hardware", "FullscreenRes", cFSResolution);
+    iniFile.Set("Hardware", "Fullscreen", bFullscreen);
+    iniFile.Set("Hardware", "VSync", bVSync);
+    iniFile.Set("Hardware", "RenderToMainframe", RenderToMainframe);
+    iniFile.Set("Settings", "StretchToFit", bNativeResolution);
+	iniFile.Set("Settings", "2xResolution", b2xResolution);
+    iniFile.Set("Settings", "KeepAR_4_3", bKeepAR43);
+	iniFile.Set("Settings", "KeepAR_16_9", bKeepAR169);
+	iniFile.Set("Settings", "Crop", bCrop);
+	iniFile.Set("Settings", "wideScreenHack", bWidescreenHack);
+    iniFile.Set("Settings", "HideCursor", bHideCursor);
+    iniFile.Set("Settings", "UseXFB", bUseXFB);
+    iniFile.Set("Settings", "AutoScale", bAutoScale);
+
+    iniFile.Set("Settings", "SafeTextureCache", bSafeTextureCache);
+    iniFile.Set("Settings", "ShowFPS", bShowFPS);
+    iniFile.Set("Settings", "OverlayStats", bOverlayStats);
+	iniFile.Set("Settings", "OverlayProjStats", bOverlayProjStats);
+    iniFile.Set("Settings", "DLOptimize", iCompileDLsLevel);
+	iniFile.Set("Settings", "Show", iCompileDLsLevel);
+    iniFile.Set("Settings", "DumpTextures", bDumpTextures);
+    iniFile.Set("Settings", "HiresTextures", bHiresTextures);
+	iniFile.Set("Settings", "DumpEFBTarget", bDumpEFBTarget);
+	iniFile.Set("Settings", "DumpFrames", bDumpFrames);
+    iniFile.Set("Settings", "FreeLook", bFreeLook);
+    iniFile.Set("Settings", "ShowEFBCopyRegions", bShowEFBCopyRegions);
+	iniFile.Set("Settings", "ShowShaderErrors", bShowShaderErrors);
+    iniFile.Set("Settings", "MSAA", iMultisampleMode);
+    iniFile.Set("Settings", "TexFmtOverlayEnable", bTexFmtOverlayEnable);
+    iniFile.Set("Settings", "TexFmtOverlayCenter", bTexFmtOverlayCenter);
+    iniFile.Set("Settings", "Wireframe", bWireFrame);
+    iniFile.Set("Settings", "DisableLighting", bDisableLighting);
+    iniFile.Set("Settings", "DisableTexturing", bDisableTexturing);
+    iniFile.Set("Settings", "DstAlphaPass", bDstAlphaPass);
+	iniFile.Set("Settings", "DisableFog", bDisableFog);
+    
+    iniFile.Set("Enhancements", "ForceFiltering", bForceFiltering);
+    iniFile.Set("Enhancements", "MaxAnisotropy", iMaxAnisotropy);
+	iniFile.Set("Enhancements", "PostProcessingShader", sPostProcessingShader);
+    
+    iniFile.Set("Hacks", "EFBCopyDisable", bEFBCopyDisable);
+    iniFile.Set("Hacks", "EFBCopyDisableHotKey", bEFBCopyDisableHotKey);
+	iniFile.Set("Hacks", "EFBToTextureEnable", bCopyEFBToRAM);
+	iniFile.Set("Hacks", "ProjectionHack", iPhackvalue);
+
+	iniFile.Set("Hardware", "Adapter", iAdapter);
+	iniFile.Set("Hardware", "WindowedRes", iWindowedRes);
+	iniFile.Set("Hardware", "VSync", bVsync);
+	iniFile.Set("Hardware", "FullscreenRes", iFSResolution);
+
+    iniFile.Save(ini_file);
+}
+
+
+
+// TODO: Figure out a better place for this function.
+void ComputeDrawRectangle(int backbuffer_width, int backbuffer_height, bool flip, TargetRectangle *rc)
+{
+	float FloatGLWidth = (float)backbuffer_width;
+	float FloatGLHeight = (float)backbuffer_height;
+	float FloatXOffset = 0;
+	float FloatYOffset = 0;
+
+	// The rendering window size
+	const float WinWidth = FloatGLWidth;
+	const float WinHeight = FloatGLHeight;
+
+	// Handle aspect ratio.
+	if (g_ActiveConfig.bKeepAR43 || g_ActiveConfig.bKeepAR169)
+	{
+		// The rendering window aspect ratio as a proportion of the 4:3 or 16:9 ratio
+		float Ratio = (WinWidth / WinHeight) / (g_Config.bKeepAR43 ? (4.0f / 3.0f) : (16.0f / 9.0f));
+		// Check if height or width is the limiting factor. If ratio > 1 the picture is to wide and have to limit the width.
+		if (Ratio > 1)
+		{
+			// Scale down and center in the X direction.
+			FloatGLWidth /= Ratio;
+			FloatXOffset = (WinWidth - FloatGLWidth) / 2.0f;
+		}
+		// The window is too high, we have to limit the height
+		else
+		{
+			// Scale down and center in the Y direction.
+			FloatGLHeight *= Ratio;
+			FloatYOffset = FloatYOffset + (WinHeight - FloatGLHeight) / 2.0f;
+		}
+	}
+
+	// -----------------------------------------------------------------------
+	// Crop the picture from 4:3 to 5:4 or from 16:9 to 16:10.
+	//		Output: FloatGLWidth, FloatGLHeight, FloatXOffset, FloatYOffset
+	// ------------------
+	if ((g_ActiveConfig.bKeepAR43 || g_ActiveConfig.bKeepAR169) && g_ActiveConfig.bCrop)
+	{
+		float Ratio = g_Config.bKeepAR43 ? ((4.0f / 3.0f) / (5.0f / 4.0f)) : (((16.0f / 9.0f) / (16.0f / 10.0f)));
+		// The width and height we will add (calculate this before FloatGLWidth and FloatGLHeight is adjusted)
+		float IncreasedWidth = (Ratio - 1.0f) * FloatGLWidth;
+		float IncreasedHeight = (Ratio - 1.0f) * FloatGLHeight;
+		// The new width and height
+		FloatGLWidth = FloatGLWidth * Ratio;
+		FloatGLHeight = FloatGLHeight * Ratio;
+		// Adjust the X and Y offset
+		FloatXOffset = FloatXOffset - (IncreasedWidth * 0.5f);
+		FloatYOffset = FloatYOffset - (IncreasedHeight * 0.5f);
+		//NOTICE_LOG(OSREPORT, "Crop       Ratio:%1.2f IncreasedHeight:%3.0f YOffset:%3.0f", Ratio, IncreasedHeight, FloatYOffset);
+		//NOTICE_LOG(OSREPORT, "Crop       FloatGLWidth:%1.2f FloatGLHeight:%3.0f", (float)FloatGLWidth, (float)FloatGLHeight);
+		//NOTICE_LOG(OSREPORT, "");
+	}
+
+	// round(float) = floor(float + 0.5)
+	int XOffset = (int)(FloatXOffset + 0.5f);
+	int YOffset = (int)(FloatYOffset + 0.5f);
+	rc->left = XOffset;
+	rc->top = flip ? (int)(YOffset + ceil(FloatGLHeight)) : YOffset;
+	rc->right = XOffset + (int)ceil(FloatGLWidth);
+	rc->bottom = flip ? YOffset : (int)(YOffset + ceil(FloatGLHeight));
+}
diff --git a/Source/Core/VideoCommon/Src/Config.h b/Source/Core/VideoCommon/Src/Config.h
new file mode 100644
index 0000000000..435a94a09b
--- /dev/null
+++ b/Source/Core/VideoCommon/Src/Config.h
@@ -0,0 +1,143 @@
+// 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/
+
+
+// IMPORTANT: UI etc should modify g_Config. Graphics code should read g_ActiveConfig.
+// The reason for this is to get rid of race conditions etc when the configuration
+// changes in the middle of a frame. This is done by copying g_Config to g_ActiveConfig
+// at the start of every frame. Noone should ever change members of g_ActiveConfig 
+// directly.
+
+#ifndef _PLUGIN_VIDEOOGL_CONFIG_H_
+#define _PLUGIN_VIDEOOGL_CONFIG_H_
+
+#include "Common.h"
+#include "VideoCommon.h"
+
+#include <string>
+
+// Log in two categories, and save three other options in the same byte
+#define CONF_LOG			1
+#define CONF_PRIMLOG		2
+#define CONF_SAVETEXTURES	4
+#define CONF_SAVETARGETS	8
+#define CONF_SAVESHADERS	16
+
+enum MultisampleMode {
+	MULTISAMPLE_OFF,
+	MULTISAMPLE_2X,
+	MULTISAMPLE_4X,
+	MULTISAMPLE_8X,
+	MULTISAMPLE_CSAA_8X,
+	MULTISAMPLE_CSAA_8XQ,
+	MULTISAMPLE_CSAA_16X,
+	MULTISAMPLE_CSAA_16XQ,
+};
+
+class IniFile;
+
+// NEVER inherit from this class.
+struct Config
+{
+    Config();
+    void Load(const char *ini_file);
+	void GameIniLoad(IniFile *iniFile);
+    void Save(const char *ini_file);
+	void UpdateProjectionHack();
+
+    // General
+    bool bFullscreen;
+    bool bHideCursor;
+    bool RenderToMainframe;
+	bool bVSync;
+
+	// Resolution control
+	char cFSResolution[16];
+    char cInternalRes[16];
+
+    bool bNativeResolution, b2xResolution, bRunning;  // Should possibly be augmented with 2x, 4x native.
+	bool bWidescreenHack;
+    bool bKeepAR43, bKeepAR169, bCrop;   // Aspect ratio controls.
+    bool bUseXFB;
+    bool bAutoScale;  // Removes annoying borders without using XFB. Doesn't always work perfectly.
+    
+	// Enhancements
+    int iMultisampleMode;
+    bool bForceFiltering;
+    int iMaxAnisotropy;
+	std::string sPostProcessingShader;
+
+	// Information
+    bool bShowFPS;
+    bool bOverlayStats;
+	bool bOverlayProjStats;
+    bool bTexFmtOverlayEnable;
+    bool bTexFmtOverlayCenter;
+	bool bShowEFBCopyRegions;
+    
+    // Render
+    bool bWireFrame;
+    bool bDisableLighting;
+    bool bDisableTexturing;
+    bool bDstAlphaPass;
+	bool bDisableFog;
+    
+    // Utility
+    bool bDumpTextures;
+	bool bHiresTextures;
+	bool bDumpEFBTarget;
+	bool bDumpFrames;
+    bool bFreeLook;
+    
+    // Hacks
+    bool bEFBCopyDisable;
+    bool bEFBCopyDisableHotKey;
+	bool bHack;
+	bool bCopyEFBToRAM;
+    bool bSafeTextureCache;
+	int iPhackvalue;
+	bool bPhackvalue1, bPhackvalue2;
+	float fhackvalue1, fhackvalue2;
+	bool bProjHack1;
+
+    int iLog; // CONF_ bits
+    int iSaveTargetId;
+    
+    //currently unused:
+    int iCompileDLsLevel;
+    bool bShowShaderErrors;
+
+	// D3D only config, mostly to be merged into the above
+	int iAdapter;
+	int iWindowedRes;
+	int iFSResolution;
+
+	bool bVsync;
+
+	// Runtime detection config
+	bool bOldCard;
+};
+
+extern Config g_Config;
+extern Config g_ActiveConfig;
+
+// Called every frame.
+void UpdateActiveConfig();
+
+void ComputeDrawRectangle(int backbuffer_width, int backbuffer_height, bool flip, TargetRectangle *rc);
+
+#endif  // _PLUGIN_VIDEOOGL_CONFIG_H_
diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.h b/Source/Core/VideoCommon/Src/PixelShaderManager.h
index ed550ce8a0..851a15f4bc 100644
--- a/Source/Core/VideoCommon/Src/PixelShaderManager.h
+++ b/Source/Core/VideoCommon/Src/PixelShaderManager.h
@@ -23,6 +23,7 @@
 
 void SetPSConstant4f(int const_number, float f1, float f2, float f3, float f4);
 void SetPSConstant4fv(int const_number, const float *f);
+void SetMultiPSConstant4fv(int const_number, int count, const float *f);
 
 // The non-API dependent parts.
 class PixelShaderManager
diff --git a/Source/Core/VideoCommon/Src/SConscript b/Source/Core/VideoCommon/Src/SConscript
index 2ceb3d8840..69724c541e 100644
--- a/Source/Core/VideoCommon/Src/SConscript
+++ b/Source/Core/VideoCommon/Src/SConscript
@@ -3,6 +3,7 @@
 Import('env')
 
 files = [
+	'Config.cpp',
 	'GlobalControl.cpp',
 	'BPMemory.cpp',
 	'CPMemory.cpp',
diff --git a/Source/Core/VideoCommon/Src/Statistics.cpp b/Source/Core/VideoCommon/Src/Statistics.cpp
index 4cfaac0724..c7cde6d408 100644
--- a/Source/Core/VideoCommon/Src/Statistics.cpp
+++ b/Source/Core/VideoCommon/Src/Statistics.cpp
@@ -43,7 +43,7 @@ void Statistics::SwapDL()
 	Xchg(stats.thisFrame.numBPLoadsInDL, stats.thisFrame.numBPLoads);
 }
 
-void Statistics::ToString(char *ptr)
+char *Statistics::ToString(char *ptr)
 {
 	char *p = ptr;
 	p+=sprintf(p,"textures created: %i\n",stats.numTexturesCreated);
@@ -72,10 +72,11 @@ void Statistics::ToString(char *ptr)
 	VertexLoaderManager::AppendListToString(&text1);
 	// TODO: Check for buffer overflow
 	p+=sprintf(p,"%s",text1.c_str());
+	return p;
 }
 
 // Is this really needed?
-void Statistics::ToStringProj(char *ptr) {
+char *Statistics::ToStringProj(char *ptr) {
 	char *p = ptr;
 	p+=sprintf(p,"Projection #: X for Raw 6=0 (X for Raw 6!=0)\n\n");
 	p+=sprintf(p,"Projection 0: %f (%f) Raw 0: %f\n", stats.gproj_0, stats.g2proj_0, stats.proj_0);
@@ -94,4 +95,5 @@ void Statistics::ToStringProj(char *ptr) {
 	p+=sprintf(p,"Projection 13: %f (%f)\n", stats.gproj_13, stats.g2proj_13);
 	p+=sprintf(p,"Projection 14: %f (%f)\n", stats.gproj_14, stats.g2proj_14);
 	p+=sprintf(p,"Projection 15: %f (%f)\n", stats.gproj_15, stats.g2proj_15);
+	return p;
 }
diff --git a/Source/Core/VideoCommon/Src/Statistics.h b/Source/Core/VideoCommon/Src/Statistics.h
index 151cfbe2db..1061041e7f 100644
--- a/Source/Core/VideoCommon/Src/Statistics.h
+++ b/Source/Core/VideoCommon/Src/Statistics.h
@@ -78,8 +78,8 @@ struct Statistics
 
 	// Yeah, this is unsafe, but we really don't wanna faff around allocating
 	// buffers here.
-	static void ToString(char *ptr);
-	static void ToStringProj(char *ptr);
+	static char *ToString(char *ptr);
+	static char *ToStringProj(char *ptr);
 };
 
 extern Statistics stats;
diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h
index d1203b86c9..5df177028a 100644
--- a/Source/Core/VideoCommon/Src/VideoCommon.h
+++ b/Source/Core/VideoCommon/Src/VideoCommon.h
@@ -121,7 +121,15 @@ struct EFBRectangle : public MathUtil::Rectangle<int>
 // depend on the resolution settings. Use Renderer::ConvertEFBRectangle to
 // convert an EFBRectangle to a TargetRectangle.
 struct TargetRectangle : public MathUtil::Rectangle<int>
-{};
+{
+#ifdef _WIN32
+	// Only used by D3D plugin.
+	const RECT *AsRECT() {
+		// The types are binary compatible so this works.
+		return (const RECT *)this;
+	}
+#endif
+};
 
 #ifdef _WIN32
 #define PRIM_LOG(...) {DEBUG_LOG(VIDEO, __VA_ARGS__)}
diff --git a/Source/Core/VideoCommon/VideoCommon.vcproj b/Source/Core/VideoCommon/VideoCommon.vcproj
index 8878848ea5..eee7206a39 100644
--- a/Source/Core/VideoCommon/VideoCommon.vcproj
+++ b/Source/Core/VideoCommon/VideoCommon.vcproj
@@ -690,6 +690,14 @@
 			</File>

 		</Filter>

 		<File

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

+			>

+		</File>

+		<File

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

+			>

+		</File>

+		<File

 			RelativePath=".\Src\GlobalControl.cpp"

 			>

 		</File>