Merge branch 'master' into GLSL-master

Conflicts:
	CMakeLists.txt
	Source/Core/DolphinWX/CMakeLists.txt
	Source/Core/DolphinWX/Src/GLInterface.h
	Source/Core/VideoCommon/Src/PixelShaderGen.cpp
	Source/Core/VideoCommon/Src/TextureCacheBase.cpp
	Source/Core/VideoCommon/Src/VertexManagerBase.cpp
	Source/Plugins/Plugin_VideoDX11/Src/VertexManager.cpp
	Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp
	Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj
	Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcxproj.filters
	Source/Plugins/Plugin_VideoOGL/Src/GLUtil.h
	Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp
	Source/Plugins/Plugin_VideoOGL/Src/TextureCache.cpp
	Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp
	Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp
	Source/Plugins/Plugin_VideoOGL/Src/main.cpp

Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj

@@ -199,6 +199,7 @@
     <ClCompile Include="Src\LineGeometryShader.cpp" />
     <ClCompile Include="Src\main.cpp" />
     <ClCompile Include="Src\NativeVertexFormat.cpp" />
+    <ClCompile Include="Src\PerfQuery.cpp" />
     <ClCompile Include="Src\PixelShaderCache.cpp" />
     <ClCompile Include="Src\PointGeometryShader.cpp" />
     <ClCompile Include="Src\PSTextureEncoder.cpp" />
@@ -228,6 +229,7 @@
     <ClInclude Include="Src\Globals.h" />
     <ClInclude Include="Src\LineGeometryShader.h" />
     <ClInclude Include="Src\main.h" />
+    <ClInclude Include="Src\PerfQuery.h" />
     <ClInclude Include="Src\PixelShaderCache.h" />
     <ClInclude Include="Src\PointGeometryShader.h" />
     <ClInclude Include="Src\PSTextureEncoder.h" />

Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj.filters

@@ -57,6 +57,9 @@
     <ClCompile Include="Src\PointGeometryShader.cpp">
       <Filter>Render</Filter>
     </ClCompile>
+    <ClCompile Include="Src\PerfQuery.cpp">
+      <Filter>Render</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Src\Globals.h" />
@@ -117,6 +120,9 @@
     <ClInclude Include="Src\PointGeometryShader.h">
       <Filter>Render</Filter>
     </ClInclude>
+    <ClInclude Include="Src\PerfQuery.h">
+      <Filter>Render</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="D3D">

Source/Plugins/Plugin_VideoDX11/Src/D3DShader.cpp

@@ -64,7 +64,8 @@ bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
 		static int num_failures = 0;
 		char szTemp[MAX_PATH];
 		sprintf(szTemp, "%sbad_vs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
-		std::ofstream file(szTemp);
+		std::ofstream file;
+		OpenFStream(file, szTemp, std::ios_base::out);
 		file << code;
 		file.close();
 
@@ -121,7 +122,8 @@ bool CompileGeometryShader(const char* code, unsigned int len, D3DBlob** blob,
 		static int num_failures = 0;
 		char szTemp[MAX_PATH];
 		sprintf(szTemp, "%sbad_gs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
-		std::ofstream file(szTemp);
+		std::ofstream file;
+		OpenFStream(file, szTemp, std::ios_base::out);
 		file << code;
 		file.close();
 
@@ -180,7 +182,8 @@ bool CompilePixelShader(const char* code, unsigned int len, D3DBlob** blob,
 		static int num_failures = 0;
 		char szTemp[MAX_PATH];
 		sprintf(szTemp, "%sbad_ps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
-		std::ofstream file(szTemp);
+		std::ofstream file;
+		OpenFStream(file, szTemp, std::ios_base::out);
 		file << code;
 		file.close();
 

Source/Plugins/Plugin_VideoDX11/Src/PerfQuery.cpp

@@ -0,0 +1,150 @@
+#include "RenderBase.h"
+
+#include "D3DBase.h"
+#include "PerfQuery.h"
+
+namespace DX11 {
+
+PerfQuery::PerfQuery()
+	: m_query_read_pos()
+	, m_query_count()
+{
+	for (int i = 0; i != ARRAYSIZE(m_query_buffer); ++i)
+	{
+		D3D11_QUERY_DESC qdesc = CD3D11_QUERY_DESC(D3D11_QUERY_OCCLUSION, 0);
+		D3D::device->CreateQuery(&qdesc, &m_query_buffer[i].query);
+	}
+	ResetQuery();
+}
+
+PerfQuery::~PerfQuery()
+{
+	for (int i = 0; i != ARRAYSIZE(m_query_buffer); ++i)
+	{
+		// TODO: EndQuery?
+		m_query_buffer[i].query->Release();
+	}
+}
+
+void PerfQuery::EnableQuery(PerfQueryGroup type)
+{
+	// Is this sane?
+	if (m_query_count > ARRAYSIZE(m_query_buffer) / 2)
+		WeakFlush();
+
+	if (ARRAYSIZE(m_query_buffer) == m_query_count)
+	{
+		// TODO
+		FlushOne();
+		ERROR_LOG(VIDEO, "flushed query buffer early!");
+	}
+
+	// start query
+	if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP)
+	{
+		auto& entry = m_query_buffer[(m_query_read_pos + m_query_count) % ARRAYSIZE(m_query_buffer)];
+
+		D3D::context->Begin(entry.query);
+		entry.query_type = type;
+
+		++m_query_count;
+	}
+}
+
+void PerfQuery::DisableQuery(PerfQueryGroup type)
+{
+	// stop query
+	if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP)
+	{
+		auto& entry = m_query_buffer[(m_query_read_pos + m_query_count + ARRAYSIZE(m_query_buffer)-1) % ARRAYSIZE(m_query_buffer)];
+		D3D::context->End(entry.query);
+	}
+}
+
+void PerfQuery::ResetQuery()
+{
+	m_query_count = 0;
+	std::fill_n(m_results, ARRAYSIZE(m_results), 0);
+}
+
+u32 PerfQuery::GetQueryResult(PerfQueryType type)
+{
+	u32 result = 0;
+
+	if (type == PQ_ZCOMP_INPUT_ZCOMPLOC || type == PQ_ZCOMP_OUTPUT_ZCOMPLOC)
+	{
+		result = m_results[PQG_ZCOMP_ZCOMPLOC];
+	}
+	else if (type == PQ_ZCOMP_INPUT || type == PQ_ZCOMP_OUTPUT)
+	{
+		result = m_results[PQG_ZCOMP];
+	}
+	else if (type == PQ_BLEND_INPUT)
+	{
+		result = m_results[PQG_ZCOMP] + m_results[PQG_ZCOMP_ZCOMPLOC];
+	}
+	else if (type == PQ_EFB_COPY_CLOCKS)
+	{
+		result = m_results[PQG_EFB_COPY_CLOCKS];
+	}
+
+	return result / 4;
+}
+
+void PerfQuery::FlushOne()
+{
+	auto& entry = m_query_buffer[m_query_read_pos];
+
+	UINT64 result = 0;
+	HRESULT hr = S_FALSE;
+	while (hr != S_OK)
+	{
+		// TODO: Might cause us to be stuck in an infinite loop!
+		hr = D3D::context->GetData(entry.query, &result, sizeof(result), 0);
+	}
+
+	// NOTE: Reported pixel metrics should be referenced to native resolution
+	m_results[entry.query_type] += (u64)result * EFB_WIDTH / g_renderer->GetTargetWidth() * EFB_HEIGHT / g_renderer->GetTargetHeight();
+
+	m_query_read_pos = (m_query_read_pos + 1) % ARRAYSIZE(m_query_buffer);
+	--m_query_count;
+}
+
+// TODO: could selectively flush things, but I don't think that will do much
+void PerfQuery::FlushResults()
+{
+	while (!IsFlushed())
+		FlushOne();
+}
+
+void PerfQuery::WeakFlush()
+{
+	while (!IsFlushed())
+	{
+		auto& entry = m_query_buffer[m_query_read_pos];
+
+		UINT64 result = 0;
+		HRESULT hr = D3D::context->GetData(entry.query, &result, sizeof(result), D3D11_ASYNC_GETDATA_DONOTFLUSH);
+
+		if (hr == S_OK)
+		{
+			// NOTE: Reported pixel metrics should be referenced to native resolution
+			m_results[entry.query_type] += (u64)result * EFB_WIDTH / g_renderer->GetTargetWidth() * EFB_HEIGHT / g_renderer->GetTargetHeight();
+
+			m_query_read_pos = (m_query_read_pos + 1) % ARRAYSIZE(m_query_buffer);
+			--m_query_count;
+		}
+		else
+		{
+			break;
+		}
+	}
+}
+
+bool PerfQuery::IsFlushed() const
+{
+	return 0 == m_query_count;
+}
+
+
+} // namespace

Source/Plugins/Plugin_VideoDX11/Src/PerfQuery.h

@@ -0,0 +1,46 @@
+#ifndef _PERFQUERY_H_
+#define _PERFQUERY_H_
+
+#include "PerfQueryBase.h"
+
+namespace DX11 {
+
+class PerfQuery : public PerfQueryBase
+{
+public:
+	PerfQuery();
+	~PerfQuery();
+
+	void EnableQuery(PerfQueryGroup type);
+	void DisableQuery(PerfQueryGroup type);
+	void ResetQuery();
+	u32 GetQueryResult(PerfQueryType type);
+	void FlushResults();
+	bool IsFlushed() const;
+
+private:
+	struct ActiveQuery
+	{
+		ID3D11Query* query;
+		PerfQueryGroup query_type;
+	};
+
+	void WeakFlush();
+
+	// Only use when non-empty
+	void FlushOne();
+
+	// when testing in SMS: 64 was too small, 128 was ok
+	static const int PERF_QUERY_BUFFER_SIZE = 512;
+
+	ActiveQuery m_query_buffer[PERF_QUERY_BUFFER_SIZE];
+	int m_query_read_pos;
+
+	// TODO: sloppy
+	volatile int m_query_count;
+	volatile u32 m_results[PQG_NUM_MEMBERS];
+};
+
+} // namespace
+
+#endif // _PERFQUERY_H_

Source/Plugins/Plugin_VideoDX11/Src/Render.cpp

@@ -65,6 +65,7 @@ ID3D11RasterizerState* resetraststate = NULL;
 
 static ID3D11Texture2D* s_screenshot_texture = NULL;
 
+
 // GX pipeline state
 struct
 {
@@ -761,11 +762,11 @@ bool Renderer::SaveScreenshot(const std::string &filename, const TargetRectangle
 	return SUCCEEDED(hr);
 }
 
-void formatBufferDump(const char *in, char *out, int w, int h, int p)
+void formatBufferDump(const u8* in, u8* out, int w, int h, int p)
 {
 	for (int y = 0; y < h; ++y)
 	{
-		const u8 *line = (u8*)(in + (h - y - 1) * p);
+		auto line = (in + (h - y - 1) * p);
 		for (int x = 0; x < w; ++x)
 		{
 			out[0] = line[2];
@@ -782,8 +783,8 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 {
 	if (g_bSkipCurrentFrame || (!XFBWrited && !g_ActiveConfig.RealXFBEnabled()) || !fbWidth || !fbHeight)
 	{
-		if (g_ActiveConfig.bDumpFrames && frame_data)
-			AVIDump::AddFrame(frame_data);
+		if (g_ActiveConfig.bDumpFrames && !frame_data.empty())
+			AVIDump::AddFrame(&frame_data[0], fbWidth, fbHeight);
 
 		Core::Callback_VideoCopiedToXFB(false);
 		return;
@@ -794,8 +795,8 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 	const XFBSourceBase* const* xfbSourceList = FramebufferManager::GetXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
 	if ((!xfbSourceList || xfbCount == 0) && g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
 	{
-		if (g_ActiveConfig.bDumpFrames && frame_data)
-			AVIDump::AddFrame(frame_data);
+		if (g_ActiveConfig.bDumpFrames && !frame_data.empty())
+			AVIDump::AddFrame(&frame_data[0], fbWidth, fbHeight);
 
 		Core::Callback_VideoCopiedToXFB(false);
 		return;
@@ -934,16 +935,15 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 			D3D11_MAPPED_SUBRESOURCE map;
 			D3D::context->Map(s_screenshot_texture, 0, D3D11_MAP_READ, 0, &map);
 
-			if (!frame_data || w != s_recordWidth || h != s_recordHeight)
+			if (frame_data.empty() || w != s_recordWidth || h != s_recordHeight)
 			{
-				delete[] frame_data;
-				frame_data = new char[3 * s_recordWidth * s_recordHeight];
+				frame_data.resize(3 * s_recordWidth * s_recordHeight);
 				w = s_recordWidth;
 				h = s_recordHeight;
 			}
-			char* source_ptr = (char*)map.pData + GetTargetRectangle().left*4 + GetTargetRectangle().top*map.RowPitch;
-			formatBufferDump(source_ptr, frame_data, s_recordWidth, s_recordHeight, map.RowPitch);
-			AVIDump::AddFrame(frame_data);
+			auto source_ptr = (const u8*)map.pData + GetTargetRectangle().left*4 + GetTargetRectangle().top*map.RowPitch;
+			formatBufferDump(source_ptr, &frame_data[0], s_recordWidth, s_recordHeight, map.RowPitch);
+			AVIDump::AddFrame(&frame_data[0], fbWidth, fbHeight);
 			D3D::context->Unmap(s_screenshot_texture, 0);
 		}
 		bLastFrameDumped = true;
@@ -952,7 +952,7 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
 	{
 		if (bLastFrameDumped && bAVIDumping)
 		{
-			SAFE_DELETE_ARRAY(frame_data);
+			std::vector<u8>().swap(frame_data);
 			w = h = 0;
 
 			AVIDump::Stop();

Source/Plugins/Plugin_VideoDX11/Src/TextureCache.cpp

@@ -58,7 +58,7 @@ bool TextureCache::TCacheEntry::Save(const char filename[], unsigned int level)
 	return SUCCEEDED(PD3DX11SaveTextureToFileA(D3D::context, texture->GetTex(), D3DX11_IFF_PNG, filename));
 }
 
-void TextureCache::TCacheEntry::Load(unsigned int stage, unsigned int width, unsigned int height,
+void TextureCache::TCacheEntry::Load(unsigned int width, unsigned int height,
 	unsigned int expanded_width, unsigned int level)
 {
 	D3D::ReplaceRGBATexture2D(texture->GetTex(), TextureCache::temp, width, height, expanded_width, level, usage);
@@ -98,6 +98,9 @@ TextureCache::TCacheEntryBase* TextureCache::CreateTexture(unsigned int width,
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)entry->texture->GetSRV(), "shader resource view of a texture of the TextureCache");	
 
 	SAFE_RELEASE(pTexture);
+	
+	if (tex_levels != 1)
+		entry->Load(width, height, expanded_width, 0);
 
 	return entry;
 }

Source/Plugins/Plugin_VideoDX11/Src/TextureCache.h

@@ -40,7 +40,7 @@ private:
 		TCacheEntry(D3DTexture2D *_tex) : texture(_tex) {}
 		~TCacheEntry();
 
-		void Load(unsigned int stage, unsigned int width, unsigned int height,
+		void Load(unsigned int width, unsigned int height,
 			unsigned int expanded_width, unsigned int levels);
 
 		void FromRenderTarget(u32 dstAddr, unsigned int dstFormat,

Source/Plugins/Plugin_VideoDX11/Src/VertexManager.cpp

@@ -104,7 +104,7 @@ void VertexManager::PrepareDrawBuffers()
 {
 	D3D11_MAPPED_SUBRESOURCE map;
 
-	UINT vSize = UINT(s_pCurBufferPointer - LocalVBuffer);
+	UINT vSize = UINT(s_pCurBufferPointer - s_pBaseBufferPointer);
 	D3D11_MAP MapType = D3D11_MAP_WRITE_NO_OVERWRITE;
 	if (m_vertex_buffer_cursor + vSize >= VBUFFER_SIZE)
 	{
@@ -116,7 +116,7 @@ void VertexManager::PrepareDrawBuffers()
 
 	D3D::context->Map(m_vertex_buffers[m_current_vertex_buffer], 0, MapType, 0, &map);
 
-	memcpy((u8*)map.pData + m_vertex_buffer_cursor, LocalVBuffer, vSize);
+	memcpy((u8*)map.pData + m_vertex_buffer_cursor, s_pBaseBufferPointer, vSize);
 	D3D::context->Unmap(m_vertex_buffers[m_current_vertex_buffer], 0);
 	m_vertex_draw_offset = m_vertex_buffer_cursor;
 	m_vertex_buffer_cursor += vSize;
@@ -136,9 +136,9 @@ void VertexManager::PrepareDrawBuffers()
 	m_triangle_draw_index = m_index_buffer_cursor;
 	m_line_draw_index = m_triangle_draw_index + IndexGenerator::GetTriangleindexLen();
 	m_point_draw_index = m_line_draw_index + IndexGenerator::GetLineindexLen();
-	memcpy((u16*)map.pData + m_triangle_draw_index, TIBuffer, sizeof(u16) * IndexGenerator::GetTriangleindexLen());
-	memcpy((u16*)map.pData + m_line_draw_index, LIBuffer, sizeof(u16) * IndexGenerator::GetLineindexLen());
-	memcpy((u16*)map.pData + m_point_draw_index, PIBuffer, sizeof(u16) * IndexGenerator::GetPointindexLen());
+	memcpy((u16*)map.pData + m_triangle_draw_index, GetTriangleIndexBuffer(), sizeof(u16) * IndexGenerator::GetTriangleindexLen());
+	memcpy((u16*)map.pData + m_line_draw_index, GetLineIndexBuffer(), sizeof(u16) * IndexGenerator::GetLineindexLen());
+	memcpy((u16*)map.pData + m_point_draw_index, GetPointIndexBuffer(), sizeof(u16) * IndexGenerator::GetPointindexLen());
 	D3D::context->Unmap(m_index_buffers[m_current_index_buffer], 0);
 	m_index_buffer_cursor += iCount;
 }
@@ -211,8 +211,6 @@ void VertexManager::Draw(UINT stride)
 
 void VertexManager::vFlush()
 {
-	VideoFifo_CheckEFBAccess();
-
 	u32 usedtextures = 0;
 	for (u32 i = 0; i < (u32)bpmem.genMode.numtevstages + 1; ++i)
 		if (bpmem.tevorders[i / 2].getEnable(i & 1))
@@ -260,26 +258,25 @@ void VertexManager::vFlush()
 		g_nativeVertexFmt->m_components))
 	{
 		GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");});
-		goto shader_fail;
+		return;
 	}
 	if (!VertexShaderCache::SetShader(g_nativeVertexFmt->m_components))
 	{
 		GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");});
-		goto shader_fail;
+		return;
 	}
 	PrepareDrawBuffers();
 	unsigned int stride = g_nativeVertexFmt->GetVertexStride();
 	g_nativeVertexFmt->SetupVertexPointers();
 	g_renderer->ApplyState(useDstAlpha);
-	
+
+	g_perf_query->EnableQuery(bpmem.zcontrol.early_ztest ? PQG_ZCOMP_ZCOMPLOC : PQG_ZCOMP);
 	Draw(stride);
+	g_perf_query->DisableQuery(bpmem.zcontrol.early_ztest ? PQG_ZCOMP_ZCOMPLOC : PQG_ZCOMP);
 
 	GFX_DEBUGGER_PAUSE_AT(NEXT_FLUSH, true);
 
 	g_renderer->RestoreState();
-
-shader_fail:
-	ResetBuffer();
 }
 
 }  // namespace

Source/Plugins/Plugin_VideoDX11/Src/main.cpp

@@ -42,6 +42,7 @@
 
 #include "D3DUtil.h"
 #include "D3DBase.h"
+#include "PerfQuery.h"
 #include "PixelShaderCache.h"
 #include "TextureCache.h"
 #include "VertexManager.h"
@@ -90,6 +91,7 @@ void InitBackendInfo()
 
 	g_Config.backend_info.APIType = API_D3D11;
 	g_Config.backend_info.bUseRGBATextures = true; // the GX formats barely match any D3D11 formats
+	g_Config.backend_info.bUseMinimalMipCount = true;
 	g_Config.backend_info.bSupports3DVision = false;
 	g_Config.backend_info.bSupportsDualSourceBlend = true;
 	g_Config.backend_info.bSupportsFormatReinterpretation = true;
@@ -101,15 +103,13 @@ void InitBackendInfo()
 	if (FAILED(hr))
 		PanicAlert("Failed to create IDXGIFactory object");
 
-	char tmpstr[512] = {};
-	DXGI_ADAPTER_DESC desc;
 	// adapters
 	g_Config.backend_info.Adapters.clear();
 	g_Config.backend_info.AAModes.clear();
 	while (factory->EnumAdapters((UINT)g_Config.backend_info.Adapters.size(), &ad) != DXGI_ERROR_NOT_FOUND)
 	{
+		DXGI_ADAPTER_DESC desc;
 		ad->GetDesc(&desc);
-		WideCharToMultiByte(/*CP_UTF8*/CP_ACP, 0, desc.Description, -1, tmpstr, 512, 0, false);
 
 		// TODO: These don't get updated on adapter change, yet
 		if (g_Config.backend_info.Adapters.size() == g_Config.iAdapter)
@@ -126,7 +126,7 @@ void InitBackendInfo()
 			}
 		}
 
-		g_Config.backend_info.Adapters.push_back(tmpstr);
+		g_Config.backend_info.Adapters.push_back(UTF16ToUTF8(desc.Description));
 		ad->Release();
 	}
 
@@ -184,6 +184,7 @@ void VideoBackend::Video_Prepare()
 	g_renderer = new Renderer;
 	g_texture_cache = new TextureCache;
 	g_vertex_manager = new VertexManager;
+	g_perf_query = new PerfQuery;
 	VertexShaderCache::Init();
 	PixelShaderCache::Init();
 	D3D::InitUtils();
@@ -227,6 +228,7 @@ void VideoBackend::Shutdown()
 		D3D::ShutdownUtils();
 		PixelShaderCache::Shutdown();
 		VertexShaderCache::Shutdown();
+		delete g_perf_query;
 		delete g_vertex_manager;
 		delete g_texture_cache;
 		delete g_renderer;