+Unity Runtime codeHEADmaster

1 files changed, 610 insertions, 0 deletions

diff --git a/Runtime/GfxDevice/d3d11/D3D11Context.cpp b/Runtime/GfxDevice/d3d11/D3D11Context.cpp
new file mode 100644
index 0000000..06abd9b
--- /dev/null
+++ b/Runtime/GfxDevice/d3d11/D3D11Context.cpp
@@ -0,0 +1,610 @@
+#include "UnityPrefix.h"
+
+#if !UNITY_WP8 && !UNITY_METRO
+
+#include "D3D11Context.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/Shaders/GraphicsCaps.h"
+#include "Runtime/Profiler/ExternalGraphicsProfiler.h"
+#include "D3D11Includes.h"
+#include "D3D11Utils.h"
+#include "TexturesD3D11.h"
+#include "TimerQueryD3D11.h"
+#include "Runtime/Misc/QualitySettings.h"
+#include "Runtime/Math/ColorSpaceConversion.h"
+#include "Runtime/Utilities/ArrayUtility.h"
+#include "Runtime/Utilities/LogUtility.h"
+#include "PlatformDependent/Win/ComPtr.h"
+#include "Runtime/Utilities/Argv.h"
+
+
+SupportedFeatureLevels GetSupportedFeatureLevels()
+{
+	SupportedFeatureLevels features;
+
+	if (HasARGV("force-feature-level-9-1")) features.push_back(D3D_FEATURE_LEVEL_9_1);
+	if (HasARGV("force-feature-level-9-2")) features.push_back(D3D_FEATURE_LEVEL_9_2);
+	if (HasARGV("force-feature-level-9-3")) features.push_back(D3D_FEATURE_LEVEL_9_3);
+	if (HasARGV("force-feature-level-10-0")) features.push_back(D3D_FEATURE_LEVEL_10_0);
+	if (HasARGV("force-feature-level-10-1")) features.push_back(D3D_FEATURE_LEVEL_10_1);
+	if (HasARGV("force-feature-level-11-0")) features.push_back(D3D_FEATURE_LEVEL_11_0);
+
+	features.push_back(D3D_FEATURE_LEVEL_11_0);
+	features.push_back(D3D_FEATURE_LEVEL_10_1);
+	features.push_back(D3D_FEATURE_LEVEL_10_0);
+
+	return features;
+}
+
+#if ENABLE_PROFILER
+D3D11PERF_BeginEventFunc g_D3D11BeginEventFunc = NULL;
+D3D11PERF_EndEventFunc g_D3D11EndEventFunc = NULL;
+#endif
+
+using namespace win;
+
+#if !UNITY_RELEASE
+#define UNITY_DX11_CREATE_FLAGS D3D11_CREATE_DEVICE_DEBUG
+#else
+#define UNITY_DX11_CREATE_FLAGS 0
+#endif
+
+
+static D3D_FEATURE_LEVEL kSupportedFeatureLevels[] = {
+	D3D_FEATURE_LEVEL_11_0,
+	D3D_FEATURE_LEVEL_10_1,
+	D3D_FEATURE_LEVEL_10_0,
+};
+
+
+bool InitD3D11RenderDepthSurface (RenderDepthSurfaceD3D11& rs, TexturesD3D11* textures, bool sampleOnly);
+
+
+static ComPtr<ID3D11Device> s_Device = NULL;
+// DX11.1 runtime only. On older runtimes this will stay null. Internally accessed by GetGfxDevice11_1().
+static ComPtr<ID3D11Device1> s_Device11_1;
+
+static ID3D11DeviceContext* s_Context = NULL;
+static IDXGIFactory* s_DXGIFactory = NULL;
+IDXGIFactory* GetDXGIFactory() { return s_DXGIFactory; }
+static IDXGISwapChain* s_SwapChain = NULL;
+static IDXGIOutput* s_Output = NULL;
+static int s_SwapChainAA = -1;
+IDXGISwapChain* GetD3D11SwapChain() { return s_SwapChain; }
+
+static int s_SyncInterval = 0;
+int GetD3D11SyncInterval() { return s_SyncInterval; }
+
+static RenderColorSurfaceD3D11  s_BackBuffer;
+static RenderDepthSurfaceD3D11  s_DepthStencil;
+
+ID3D11RenderTargetView* g_D3D11CurrRT;
+ID3D11DepthStencilView* g_D3D11CurrDS;
+ID3D11Resource* g_D3D11CurrRTResource;
+ID3D11Resource* g_D3D11CurrDSResource;
+RenderColorSurfaceD3D11* g_D3D11CurrColorRT;
+RenderDepthSurfaceD3D11* g_D3D11CurrDepthRT;
+int g_D3D11Adapter = 0;
+int g_D3D11Output = 0;
+
+static HWND					s_Window = NULL;
+static HINSTANCE			s_D3DDll = NULL;
+static HINSTANCE			s_D3D9Dll = NULL;
+static HINSTANCE			s_DXGIDll = NULL;
+static bool					s_CurrentlyWindowed = true;
+
+typedef HRESULT (WINAPI* D3D11CreateDeviceFunc)(
+	IDXGIAdapter *pAdapter,
+	D3D_DRIVER_TYPE DriverType,
+	HMODULE Software,
+	UINT Flags,
+	CONST D3D_FEATURE_LEVEL *pFeatureLevels,
+	UINT FeatureLevels,
+	UINT SDKVersion,
+	ID3D11Device **ppDevice,
+	D3D_FEATURE_LEVEL *pFeatureLevel,
+	ID3D11DeviceContext **ppImmediateContext
+);
+
+typedef HRESULT (WINAPI* CreateDXGIFactoryFunc)(
+	REFIID ridd,
+	void** ppFactory
+);
+
+// Either selects default adapter (NULL) or n-th one,
+// defined by adapterIndex. Returned adapter
+// must be released if not NULL!
+static IDXGIAdapter* SelectAdapter (int adapterIndex)
+{
+	s_DXGIDll = LoadLibrary( "dxgi.dll" );
+	if( !s_DXGIDll )
+		return NULL;
+
+	CreateDXGIFactoryFunc createDXGIFactory = (CreateDXGIFactoryFunc)GetProcAddress( s_DXGIDll, "CreateDXGIFactory" );
+	if( !createDXGIFactory )
+		return NULL;
+
+	IDXGIAdapter* adapter = NULL;
+	if ( SUCCEEDED(createDXGIFactory(__uuidof(IDXGIFactory), (void**)&s_DXGIFactory)) )
+	{
+		for ( int i = 0; SUCCEEDED(s_DXGIFactory->EnumAdapters(i, &adapter)); ++i )
+		{
+			if ( i == adapterIndex )
+				break;
+			else
+				adapter->Release();
+		}
+	}
+
+	return adapter;
+}
+
+// Selects default output (NULL) or the one defined by outputIndex.
+// Result must be released!
+static IDXGIOutput* SelectOutput (IDXGIAdapter* adapter, int outputIndex)
+{
+	if (outputIndex == 0)
+		return NULL;
+
+	Assert(adapter);
+
+	IDXGIOutput* output = NULL;
+	for ( int i = 0; SUCCEEDED(adapter->EnumOutputs(i, &output)); ++i )
+	{
+		if ( i == outputIndex )
+			break;
+		else
+			output->Release();
+	}
+
+	return output;
+}
+
+bool InitializeD3D11 ()
+{
+	AssertIf (s_Device || s_Context || s_Window || s_D3DDll || s_D3D9Dll || s_DXGIDll);
+
+	SupportedFeatureLevels features = GetSupportedFeatureLevels();
+	IDXGIAdapter* adapter = NULL;
+
+	s_D3DDll = LoadLibrary( "d3d11.dll" );
+	if (!s_D3DDll)
+	{
+		printf_console ("d3d11: no D3D11 installed\n");
+		goto _cleanup;
+	}
+
+	D3D11CreateDeviceFunc createFunc = (D3D11CreateDeviceFunc)GetProcAddress( s_D3DDll, "D3D11CreateDevice" );
+	if( !createFunc )
+	{
+		printf_console ("d3d11: D3D11CreateDevice not found\n");
+		goto _cleanup;
+	}
+
+
+	DWORD d3d11CreateFlags = 0;
+	if (!HasARGV("force-d3d11-no-singlethreaded"))
+	{
+		d3d11CreateFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED;
+	}
+
+	adapter = SelectAdapter (g_D3D11Adapter);
+	if (adapter)
+		s_Output = SelectOutput (adapter, g_D3D11Output);
+
+	// create D3D device & immediate context,
+	// with debug layer in Debug config
+	HRESULT hr = E_FAIL;
+	D3D_FEATURE_LEVEL level;
+	D3D_DRIVER_TYPE driverType = adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE;
+	#if !UNITY_RELEASE 
+	hr = createFunc (
+		adapter, driverType, NULL,
+		d3d11CreateFlags | D3D11_CREATE_DEVICE_DEBUG,
+		&features[0],
+		features.size(),
+		D3D11_SDK_VERSION, &s_Device, &level, &s_Context
+		);
+	#endif
+	// create without debug layer if the above failed or was not called at all
+	if (FAILED(hr))
+	{
+		hr = createFunc (
+			adapter, driverType, NULL,
+			d3d11CreateFlags,
+			&features[0], features.size(),
+			D3D11_SDK_VERSION, &s_Device, &level, &s_Context
+			);
+	}
+	if (FAILED(hr))
+	{
+		printf_console( "d3d11: failed to create D3D11 device (0x%08x)\n", hr );
+		goto _cleanup;
+	}
+
+	SAFE_RELEASE(adapter);
+
+	// Query DX11.1 interface, may well fail for older runtimes and is silently ignored.
+	s_Device->QueryInterface(&s_Device11_1);
+
+	// Create DXGIFactory if it isn't already created by SelectAdapter
+	if (!s_DXGIFactory)
+	{
+		IDXGIDevice* dxgiDevice = NULL;
+		hr = s_Device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
+		IDXGIAdapter* dxgiAdapter = NULL;
+		hr = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter);
+		hr = dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&s_DXGIFactory);
+		dxgiAdapter->Release();
+		dxgiDevice->Release();
+	}
+
+
+	#if ENABLE_PROFILER
+	// Even on D3D11, PIX event marker functions are in D3D9 DLL
+	s_D3D9Dll = LoadLibrary ("d3d9.dll");
+	if (s_D3D9Dll)
+	{
+		g_D3D11BeginEventFunc = (D3D11PERF_BeginEventFunc)GetProcAddress(s_D3D9Dll, "D3DPERF_BeginEvent");
+		g_D3D11EndEventFunc = (D3D11PERF_EndEventFunc)GetProcAddress(s_D3D9Dll, "D3DPERF_EndEvent");
+	}
+	#endif
+
+	return true;
+
+_cleanup:
+	SAFE_RELEASE(adapter);
+	SAFE_RELEASE(s_Output);
+	SAFE_RELEASE(s_DXGIFactory);
+
+	s_Device11_1.Free();
+	s_Device.Free();
+
+	SAFE_RELEASE(s_Context);
+
+	if (s_D3DDll) {
+		FreeLibrary (s_D3DDll);
+		s_D3DDll = NULL;
+	}
+	if (s_D3D9Dll) {
+		FreeLibrary (s_D3D9Dll);
+		s_D3D9Dll = NULL;
+	}
+	if (s_DXGIDll) {
+		FreeLibrary (s_DXGIDll);
+		s_DXGIDll = NULL;
+	}
+	return false;
+}
+
+
+void CleanupD3D11()
+{
+	AssertIf (((ID3D11Device *)s_Device) || s_Context || s_Window);
+
+	if (s_D3DDll)
+	{
+		FreeLibrary (s_D3DDll);
+		s_D3DDll = NULL;
+	}
+	if (s_D3D9Dll)
+	{
+		FreeLibrary (s_D3D9Dll);
+		s_D3D9Dll = NULL;
+	}
+	if (s_DXGIDll) {
+		FreeLibrary (s_DXGIDll);
+		s_DXGIDll = NULL;
+	}
+}
+
+static void ReleaseBackbufferResources()
+{
+	//NESTED_LOG("DX11 debug", "ReleaseBackbufferResources");
+
+	Assert(s_Device && s_Context);
+
+	#if ENABLE_PROFILER
+	g_TimerQueriesD3D11.ReleaseAllQueries();
+	#endif
+
+	SAFE_RELEASE(s_DepthStencil.m_Texture);
+	SAFE_RELEASE(s_DepthStencil.m_SRView);
+	SAFE_RELEASE(s_DepthStencil.m_DSView);
+	s_BackBuffer.Reset();
+
+	if (s_Context)
+		s_Context->OMSetRenderTargets(0, NULL, NULL);
+}
+
+
+static void CreateBackbufferResources(GfxDevice* device, int width, int height, int antiAlias, DXGI_FORMAT swapFormat, bool sRGB)
+{
+	//NESTED_LOG("DX11 debug", "CreateBackbufferResources %ix%i", width, height);
+
+	HRESULT hr;
+
+	// Set the Backbuffer primary format flags
+	s_BackBuffer.flags = sRGB ? (s_BackBuffer.flags | kSurfaceCreateSRGB) : (s_BackBuffer.flags & ~kSurfaceCreateSRGB);
+
+	// Backbuffer
+	s_BackBuffer.width = width;
+	s_BackBuffer.height = height;
+	s_BackBuffer.samples = antiAlias;
+	s_BackBuffer.backBuffer = true;
+	s_BackBuffer.format = kRTFormatARGB32;
+
+	hr = s_SwapChain->GetBuffer (0, __uuidof(*s_BackBuffer.m_Texture), (void**)&s_BackBuffer.m_Texture);
+	Assert(SUCCEEDED(hr));
+	SetDebugNameD3D11 (s_BackBuffer.m_Texture, Format("SwapChain-BackBuffer-Texture-%dx%d", width, height));
+
+	// Create the primary backbuffer view
+	ID3D11RenderTargetView* rtv = NULL;
+	D3D11_RENDER_TARGET_VIEW_DESC rtDesc;
+	rtDesc.Format = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM;
+	rtDesc.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D;
+	rtDesc.Texture2D.MipSlice = 0;
+	hr = s_Device->CreateRenderTargetView (s_BackBuffer.m_Texture, &rtDesc, &rtv);
+	s_BackBuffer.SetRTV (0, 0, false, rtv);
+	Assert(SUCCEEDED(hr));
+	SetDebugNameD3D11 (rtv, Format("SwapChain-BackBuffer-RTV-%dx%d", width, height));
+
+	// Create the secondary backbuffer view
+	D3D11_RENDER_TARGET_VIEW_DESC rtDescSecondary;
+	rtDescSecondary.Format = !sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM;
+	rtDescSecondary.ViewDimension = antiAlias > 1 ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D;
+	rtDescSecondary.Texture2D.MipSlice = 0;
+	hr = s_Device->CreateRenderTargetView (s_BackBuffer.m_Texture, &rtDescSecondary, &rtv);
+	s_BackBuffer.SetRTV (0, 0, true, rtv);
+	Assert(SUCCEEDED(hr));
+	SetDebugNameD3D11 (rtv, Format("SwapChain-BackBuffer-RTVSec-%dx%d", width, height));
+
+	if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0)
+	{
+		// Create shader resource view
+		D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+		srvDesc.Format = swapFormat;
+		srvDesc.ViewDimension = antiAlias > 1 ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D;
+		srvDesc.Texture2D.MostDetailedMip = 0;
+		srvDesc.Texture2D.MipLevels = 1;
+
+		ID3D11ShaderResourceView* srView = NULL;
+		hr = s_Device->CreateShaderResourceView (s_BackBuffer.m_Texture, &srvDesc, &s_BackBuffer.m_SRView);
+		Assert (SUCCEEDED(hr));
+		SetDebugNameD3D11 (s_BackBuffer.m_SRView, Format("SwapChain-BackBuffer-SRV-%dx%d", width, height));
+	}
+
+	// Depth stencil
+	s_DepthStencil.width = width;
+	s_DepthStencil.height = height;
+	s_DepthStencil.samples = antiAlias;
+	s_DepthStencil.dim = kTexDim2D;
+	s_DepthStencil.backBuffer = true;
+	s_DepthStencil.depthFormat = device->GetFramebufferDepthFormat();
+	{
+		bool dsOk = InitD3D11RenderDepthSurface (s_DepthStencil, NULL, false);
+		Assert (dsOk);
+	}
+
+#if !UNITY_EDITOR
+	RenderSurfaceHandle bbHandle(&s_BackBuffer), dsHandle(&s_DepthStencil);
+	device->SetRenderTargets(1, &bbHandle, dsHandle);
+#endif
+
+	#if ENABLE_PROFILER
+	if (gGraphicsCaps.hasTimerQuery)
+		g_TimerQueriesD3D11.RecreateAllQueries();
+	#endif
+}
+
+
+bool InitializeOrResetD3D11SwapChain(
+	class GfxDevice* device,
+	HWND window, int width, int height,
+	int refreshRate, bool fullscreen, int vsynccount, int antiAlias,
+	int& outBackbufferBPP, int& outFrontbufferBPP, int& outDepthBPP, int& outFSAA )
+{
+	Assert(s_Device && s_Context);
+
+	ReleaseBackbufferResources();
+
+	outBackbufferBPP = 4;
+	outFrontbufferBPP = 4;
+	outDepthBPP = 4;
+	outFSAA = 0;
+
+	device->SetCurrentWindowSize (width, height);
+
+	// pick supported AA level
+	if (antiAlias == -1)
+		antiAlias = GetQualitySettings().GetCurrent().antiAliasing;
+	while (antiAlias > 1 && !(gGraphicsCaps.d3d11.msaa & (1<<antiAlias)))
+		--antiAlias;
+	antiAlias = std::max(antiAlias, 1);
+
+	const bool sRGB = GetActiveColorSpace() == kLinearColorSpace;
+
+	// Release old swap chain if we need to change AA
+	if (s_SwapChain && s_SwapChainAA != antiAlias)
+	{
+		// swap chain must go out of fullscreen before releasing it
+		s_SwapChain->SetFullscreenState (FALSE, NULL);
+		SAFE_RELEASE(s_SwapChain);
+	}
+
+	// Create Swap Chain
+	HRESULT hr;
+
+	DWORD swapFlags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+	DXGI_FORMAT swapFormat = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM;
+	s_SwapChainAA = antiAlias;
+	s_SyncInterval = vsynccount;
+	if (!s_SwapChain)
+	{
+		//NESTED_LOG("DX11 debug", "InitializeOrResetD3D11SwapChain, init %ix%i, window %p", width, height, window);
+
+		DXGI_SWAP_CHAIN_DESC sd;
+		ZeroMemory (&sd, sizeof(sd));
+		sd.BufferCount = 1;
+		sd.BufferDesc.Width = width;
+		sd.BufferDesc.Height = height;
+		sd.BufferDesc.Format = swapFormat;
+		sd.BufferDesc.RefreshRate.Numerator = refreshRate;
+		sd.BufferDesc.RefreshRate.Denominator = 1;
+		sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+		if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0)
+			sd.BufferUsage |= DXGI_USAGE_SHADER_INPUT;
+		sd.Flags = swapFlags;
+		sd.OutputWindow = window;
+		sd.SampleDesc.Count = antiAlias;
+		sd.SampleDesc.Quality = 0;
+		// Docs suggest always setting this to true and then doing SetFullscreenState
+		sd.Windowed = TRUE;
+		hr = s_DXGIFactory->CreateSwapChain (s_Device, &sd, &s_SwapChain);
+		Assert(SUCCEEDED(hr));
+
+		// We'll handle Alt-Enter and other things ourselves
+		DWORD dxgiFlags = DXGI_MWA_NO_ALT_ENTER | DXGI_MWA_NO_WINDOW_CHANGES;
+		s_DXGIFactory->MakeWindowAssociation (window, dxgiFlags);
+
+		if (fullscreen)
+			s_SwapChain->SetFullscreenState(TRUE, s_Output);
+
+		CreateBackbufferResources(device, width, height, antiAlias, swapFormat, sRGB);
+	}
+	else
+	{
+		DXGI_MODE_DESC mode;
+		mode.Width = width;
+		mode.Height = height;
+		mode.RefreshRate.Numerator = refreshRate;
+		mode.RefreshRate.Denominator = 1;
+		mode.Format = swapFormat;
+		mode.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
+		mode.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
+
+		//NESTED_LOG("DX11 debug", "InitializeOrResetD3D11SwapChain, resize %ix%i, fs=%i, window %p", width, height, fullscreen, window);
+
+		// Note: the following will often call WM_SIZE on us, which will handle actual resizing (since size might be slightly different!),
+		// which will go into ResizeSwapD3D11SwapChain.
+
+		{
+			//NESTED_LOG("DX11 debug", "ResizeTarget 1st");
+			s_SwapChain->ResizeTarget (&mode);
+		}
+		{
+			//NESTED_LOG("DX11 debug", "SetFullscreenState");
+			s_SwapChain->SetFullscreenState (fullscreen, fullscreen ? s_Output : NULL);
+		}
+
+		// according to "DXGI: Best Practices" on MSDN, advisable
+		// to call resize target again with refresh rate zeroed out.
+		mode.RefreshRate.Numerator = 0;
+		mode.RefreshRate.Denominator = 0;
+		if (fullscreen)
+		{
+			//NESTED_LOG("DX11 debug", "ResizeTarget 2nd");
+			s_SwapChain->ResizeTarget (&mode);
+		}
+
+		// In some cases above calls do not post WM_SIZE, so ResizeSwapD3D11SwapChain is not called,
+		// which means we won't get back buffer.
+		// If we still don't have back buffer here, just set it up.
+		if (!s_BackBuffer.m_Texture)
+		{
+			CreateBackbufferResources (device, width, height, s_SwapChainAA, swapFormat, sRGB);
+		}
+	}
+
+	return true;
+}
+
+
+void ResizeSwapD3D11SwapChain (class GfxDevice* device, HWND window, int width, int height)
+{
+	if (!s_SwapChain)
+		return;
+
+	const bool hadBackBuffer = (s_DepthStencil.m_Texture != NULL);
+	if (hadBackBuffer)
+		ReleaseBackbufferResources();
+
+	device->SetCurrentWindowSize (width, height);
+
+	const bool sRGB = GetActiveColorSpace() == kLinearColorSpace;
+	DWORD swapFlags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+	DXGI_FORMAT swapFormat = sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM;
+
+	//NESTED_LOG("DX11 debug", "ResizeSwapD3D11SwapChain, resize %ix%i", width, height);
+	s_SwapChain->ResizeBuffers (1, width, height, sRGB ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM, swapFlags);
+
+	CreateBackbufferResources (device, width, height, s_SwapChainAA, swapFormat, sRGB);
+}
+
+
+
+void DestroyD3D11Device()
+{
+	// This can happen when quiting from screen selector - window is not set up yet
+	if( !((ID3D11Device *)s_Device)|| !s_Context || !s_DXGIFactory )
+		return;
+
+	// swap chain must go out of fullscreen before releasing it
+	if (s_SwapChain)
+	{
+		s_SwapChain->SetFullscreenState (FALSE, NULL);
+	}
+
+	// cleanup
+	SAFE_RELEASE(s_DepthStencil.m_Texture);
+	SAFE_RELEASE(s_DepthStencil.m_SRView);
+	SAFE_RELEASE(s_DepthStencil.m_DSView);
+	s_BackBuffer.Reset();
+	SAFE_RELEASE(s_SwapChain);
+
+	s_Context->ClearState();
+	s_Context->Flush();
+
+	s_Context->Release();
+	s_Context = NULL;
+
+	/*
+	// Helper code to report any live objects
+	ID3D11Debug *d3dDebug = NULL;
+	if (SUCCEEDED(s_Device->QueryInterface(__uuidof(ID3D11Debug), (void**)&d3dDebug)))
+	{
+		d3dDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL | D3D11_RLDO_SUMMARY);
+		d3dDebug->Release();
+	}
+	*/
+
+	s_Device11_1.Free();
+	s_Device.Free();
+
+	SAFE_RELEASE(s_Output);
+	SAFE_RELEASE(s_DXGIFactory);
+	
+	s_Window = NULL;
+}
+
+ID3D11Device* GetD3D11Device()
+{
+	AssertIf( !((ID3D11Device *)s_Device) );
+	return s_Device;
+}
+
+ID3D11Device1* GetD3D11_1Device()
+{
+	return s_Device11_1;
+}
+
+
+ID3D11DeviceContext* GetD3D11Context(bool expectNull)
+{
+	if (!expectNull)
+		Assert( s_Context );
+	return s_Context;
+}
+
+#endif
+