void InitBackendInfo()
{
HRESULT hr = DX11::D3D::LoadDXGI();
if (SUCCEEDED(hr)) hr = DX11::D3D::LoadD3D();
if (FAILED(hr))
{
DX11::D3D::UnloadDXGI();
return;
}
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.bSupports3DVision = false;
g_Config.backend_info.bSupportsDualSourceBlend = true;
g_Config.backend_info.bSupportsFormatReinterpretation = true;
g_Config.backend_info.bSupportsPixelLighting = true;
IDXGIFactory* factory;
IDXGIAdapter* ad;
hr = DX11::PCreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
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)
{
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)
{
char buf[32];
std::vector<DXGI_SAMPLE_DESC> modes;
modes = DX11::D3D::EnumAAModes(ad);
for (unsigned int i = 0; i < modes.size(); ++i)
{
if (i == 0) sprintf_s(buf, 32, "None");
else if (modes[i].Quality) sprintf_s(buf, 32, "%d samples (quality level %d)", modes[i].Count, modes[i].Quality);
else sprintf_s(buf, 32, "%d samples", modes[i].Count);
g_Config.backend_info.AAModes.push_back(buf);
}
}
g_Config.backend_info.Adapters.push_back(tmpstr);
ad->Release();
}
factory->Release();
// Clear ppshaders string vector
g_Config.backend_info.PPShaders.clear();
DX11::D3D::UnloadDXGI();
DX11::D3D::UnloadD3D();
}
static string getGPUName( IUnknown* pDevice )
{
string sRet = "";
IDXGIDevice* pDXGIDevice = NULL;
pDevice->QueryInterface( __uuidof( IDXGIDevice ), ( void** )&pDXGIDevice );
if ( pDXGIDevice )
{
IDXGIAdapter* pDXGIAdapter = NULL;
pDXGIDevice->GetAdapter( &pDXGIAdapter );
if ( pDXGIAdapter )
{
DXGI_ADAPTER_DESC adapterDesc;
pDXGIAdapter->GetDesc( &adapterDesc );
sRet = PluginManager::UTF82ACP( PluginManager::UCS22UTF8( adapterDesc.Description ) );
SAFE_RELEASE( pDXGIAdapter );
}
SAFE_RELEASE( pDXGIDevice );
}
return sRet;
}
void D3DApp::LogAdapters()
{
UINT i = 0;
IDXGIAdapter* adapter = nullptr;
std::vector<IDXGIAdapter*> adapterList;
while(mdxgiFactory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND)
{
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
std::wstring text = L"***Adapter: ";
text += desc.Description;
text += L"\n";
OutputDebugString(text.c_str());
adapterList.push_back(adapter);
++i;
}
for(size_t i = 0; i < adapterList.size(); ++i)
{
LogAdapterOutputs(adapterList[i]);
ReleaseCom(adapterList[i]);
}
}
static ovrGraphicsLuid GetDefaultAdapterLuid()
{
ovrGraphicsLuid luid = ovrGraphicsLuid();
#if defined(_WIN32)
IDXGIFactory* factory = nullptr;
if (SUCCEEDED(CreateDXGIFactory(IID_PPV_ARGS(&factory))))
{
IDXGIAdapter* adapter = nullptr;
if (SUCCEEDED(factory->EnumAdapters(0, &adapter)))
{
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
memcpy(&luid, &desc.AdapterLuid, sizeof(luid));
adapter->Release();
}
factory->Release();
}
#endif
return luid;
}
int main(int argc, char** argv)
{
IDXGIFactory1* factory = 0;
CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&factory);
IDXGIAdapter* adapter = NULL;
for (unsigned int index = 0; SUCCEEDED(factory->EnumAdapters(index, &adapter)); ++index)
{
DXGI_ADAPTER_DESC ad = {};
adapter->GetDesc(&ad);
if (ad.VendorId == 0x1414 && ad.DeviceId == 0x8c)
continue; // Skip Microsoft Basic Render Driver
printf("// GPU %d: %S (Vendor %04x Device %04x)\n", index, ad.Description, ad.VendorId, ad.DeviceId);
if (argc == 1)
{
testCache(adapter);
}
else if (argc > 1 && strcmp(argv[1], "--") == 0)
{
testCacheSequence(adapter, argc, argv);
}
else
{
testCacheMeshes(adapter, argc, argv);
}
}
}
void LogVideoCardStats()
{
HRESULT err;
IDXGIFactory *factory;
if(SUCCEEDED(err = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory)))
{
UINT i=0;
IDXGIAdapter *giAdapter;
while(factory->EnumAdapters(i++, &giAdapter) == S_OK)
{
Log(TEXT("------------------------------------------"));
DXGI_ADAPTER_DESC adapterDesc;
if(err = SUCCEEDED(giAdapter->GetDesc(&adapterDesc)))
{
Log(TEXT("Adapter %u"), i);
Log(TEXT(" Video Adapter: %s"), adapterDesc.Description);
Log(TEXT(" Video Adapeter Dedicated Video Memory: %u"), adapterDesc.DedicatedVideoMemory);
Log(TEXT(" Video Adapeter Shared System Memory: %u"), adapterDesc.SharedSystemMemory);
}
else
AppWarning(TEXT("Could not query adapter %u"), i);
giAdapter->Release();
}
factory->Release();
}
}
STDMETHODIMP CDecD3D11::GetHWAccelDeviceInfo(DWORD dwIndex, BSTR *pstrDeviceName, DWORD *dwDeviceIdentifier)
{
IDXGIAdapter *pDXGIAdapter = nullptr;
IDXGIFactory1 *pDXGIFactory = nullptr;
HRESULT hr = dx.mCreateDXGIFactory1(IID_IDXGIFactory1, (void **)&pDXGIFactory);
if (FAILED(hr))
goto fail;
hr = pDXGIFactory->EnumAdapters(dwIndex, &pDXGIAdapter);
if (FAILED(hr))
goto fail;
DXGI_ADAPTER_DESC desc;
pDXGIAdapter->GetDesc(&desc);
// stop when we hit the MS software device
if (desc.VendorId == 0x1414 && desc.DeviceId == 0x8c)
{
hr = E_INVALIDARG;
goto fail;
}
if (pstrDeviceName)
*pstrDeviceName = SysAllocString(desc.Description);
if (dwDeviceIdentifier)
*dwDeviceIdentifier = desc.DeviceId;
fail:
SafeRelease(&pDXGIFactory);
SafeRelease(&pDXGIAdapter);
return hr;
}
STDMETHODIMP_(DWORD) CDecD3D11::GetHWAccelNumDevices()
{
DWORD nDevices = 0;
UINT i = 0;
IDXGIAdapter *pDXGIAdapter = nullptr;
IDXGIFactory1 *pDXGIFactory = nullptr;
HRESULT hr = dx.mCreateDXGIFactory1(IID_IDXGIFactory1, (void **)&pDXGIFactory);
if (FAILED(hr))
goto fail;
DXGI_ADAPTER_DESC desc;
while (SUCCEEDED(pDXGIFactory->EnumAdapters(i, &pDXGIAdapter)))
{
pDXGIAdapter->GetDesc(&desc);
SafeRelease(&pDXGIAdapter);
// stop when we hit the MS software device
if (desc.VendorId == 0x1414 && desc.DeviceId == 0x8c)
break;
i++;
}
nDevices = i;
fail:
SafeRelease(&pDXGIFactory);
return nDevices;
}
std::wstring
DXGI::GetGPUInfo (void)
{
static wchar_t adapters [4096];
*adapters = L'\0';
if (!NVAPI::CountPhysicalGPUs ()) {
IDXGIFactory* pFactory = NULL;
CreateDXGIFactory (__uuidof(IDXGIFactory), (void **)&pFactory);
IDXGIAdapter* pDXGIAdapter;
for (UINT i = 0; pFactory->EnumAdapters (i, &pDXGIAdapter) != DXGI_ERROR_NOT_FOUND; ++i) {
DXGI_ADAPTER_DESC adapterDesc;
pDXGIAdapter->GetDesc (&adapterDesc);
// Skip Microsoft's virtual adapters...
if (adapterDesc.VendorId != 0x1414) {
swprintf (adapters, L"%sAdapter %02u (Vendor ID: %04X):\r\n"
L"----------------------------------------\r\n\r\n"
L" %s\r\n\r\n"
L" %4.1f GiB Dedicated VRAM\r\n"
L" %4.1f GiB Shared Memory (GART)\r\n\r\n",
adapters,
i,
adapterDesc.VendorId,
adapterDesc.Description,
(float)adapterDesc.DedicatedVideoMemory / 1024.0f / 1024.0f / 1024.0f,
(float)adapterDesc.SharedSystemMemory / 1024.0f / 1024.0f / 1024.0f);
}
pDXGIAdapter->Release ();
}
pFactory->Release ();
}
else {
DXGI_ADAPTER_DESC* adapter_descs = NVAPI::EnumGPUs_DXGI ();
int i = 0;
while (*adapter_descs [i].Description != L'\0') {
swprintf (adapters, L"%sAdapter %02d (Vendor ID: %04X):\r\n"
L"----------------------------------------\r\n\r\n"
L" %s\r\n\r\n"
L" %4.1f GiB Dedicated VRAM\r\n"
L" %4.1f GiB Shared Memory (GART)\r\n\r\n",
adapters,
i,
adapter_descs [i].VendorId,
adapter_descs [i].Description,
(float)adapter_descs [i].DedicatedVideoMemory / 1024.0f / 1024.0f / 1024.0f,
(float)adapter_descs [i].SharedSystemMemory / 1024.0f / 1024.0f / 1024.0f);
++i;
}
}
return std::wstring (adapters);
}
bool CDuplicateOutputDx11::CreateOutputDuplicator()
{
SAFE_RELEASE(m_pOutputDuplication);
HRESULT hRes = S_OK;
IDXGIDevice* pDxgiDevice = nullptr;
hRes = m_pDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&pDxgiDevice));
if (!SUCCEEDED(hRes))
{
DOLOG("m_pDevice->QueryInterface failed!");
return false;
}
IDXGIAdapter* pDxgiAdapter = nullptr;
hRes = pDxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&pDxgiAdapter));
SAFE_RELEASE(pDxgiDevice);
if (!SUCCEEDED(hRes))
{
DOLOG("pDxgiDevice->GetParent failed!");
return false;
}
DXGI_ADAPTER_DESC descAdapter;
pDxgiAdapter->GetDesc(&descAdapter);
// Get output
IDXGIOutput* pDxgiOutput = nullptr;
hRes = pDxgiAdapter->EnumOutputs(0, &pDxgiOutput);
SAFE_RELEASE(pDxgiAdapter);
if (!SUCCEEDED(hRes))
{
DOLOG("pDxgiAdapter->EnumOutputs failed!");
return false;
}
// Get output1
IDXGIOutput1* pDxgiOutput1 = nullptr;
hRes = pDxgiOutput->QueryInterface(__uuidof(IDXGIOutput1), reinterpret_cast<void**>(&pDxgiOutput1));
SAFE_RELEASE(pDxgiOutput);
if (!SUCCEEDED(hRes))
{
DOLOG("pDxgiOutput->QueryInterface failed!");
return false;
}
// Get duplicate
hRes = pDxgiOutput1->DuplicateOutput(m_pDevice, &m_pOutputDuplication);
SAFE_RELEASE(pDxgiOutput1);
if (!SUCCEEDED(hRes))
{
DOLOG("pDxgiOutput1->DuplicateOutput");
return false;
}
return true;
}
OVR_PUBLIC_FUNCTION(ovrResult) ovr_Create(ovrSession* pSession, ovrGraphicsLuid* pLuid)
{
// Initialize the opaque pointer with our own OpenVR-specific struct
ovrSession session = new struct ovrHmdStruct();
memset(session->ColorTexture, 0, sizeof(ovrHmdStruct::ColorTexture));
session->ThumbStick[ovrHand_Left] = true;
// Get the compositor interface
session->compositor = (vr::IVRCompositor*)VR_GetGenericInterface(vr::IVRCompositor_Version, &g_InitError);
if (g_InitError != vr::VRInitError_None)
return REV_InitErrorToOvrError(g_InitError);
session->compositor->SetTrackingSpace(vr::TrackingUniverseSeated);
// Get the settings interface
session->settings = (vr::IVRSettings*)VR_GetGenericInterface(vr::IVRSettings_Version, &g_InitError);
if (g_InitError != vr::VRInitError_None)
return REV_InitErrorToOvrError(g_InitError);
// Get the overlay interface
session->overlay = (vr::IVROverlay*)VR_GetGenericInterface(vr::IVROverlay_Version, &g_InitError);
if (g_InitError != vr::VRInitError_None)
return REV_InitErrorToOvrError(g_InitError);
// Apply settings
session->ThumbStickRange = session->settings->GetFloat(REV_SETTINGS_SECTION, "ThumbStickRange", 0.8f);
// Get the LUID for the adapter
int32_t index;
g_VRSystem->GetDXGIOutputInfo(&index);
if (index == -1)
index = 0;
// Create the DXGI factory
IDXGIFactory* pFactory;
HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&pFactory));
if (FAILED(hr))
return ovrError_IncompatibleGPU;
IDXGIAdapter* pAdapter;
hr = pFactory->EnumAdapters(index, &pAdapter);
if (FAILED(hr))
return ovrError_MismatchedAdapters;
DXGI_ADAPTER_DESC desc;
hr = pAdapter->GetDesc(&desc);
if (FAILED(hr))
return ovrError_MismatchedAdapters;
// Copy the LUID into the structure
memcpy(pLuid, &desc.AdapterLuid, sizeof(LUID));
// Cleanup and return
pFactory->Release();
pAdapter->Release();
*pSession = session;
return ovrSuccess;
}
// Constructor. Creates a Direct3D device.
D3D() : _Device(NULL), _ImmediateContext(NULL)
{
IDXGIFactory* factory;
if (FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory))) return;
HRESULT hr = S_OK;
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_UNKNOWN,
};
UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0 };
unsigned int numFeatureLevels = 1;
D3D_FEATURE_LEVEL usedFeatureLevel = D3D_FEATURE_LEVEL_11_0;
// iterate the display adapters and look for a DirectX 11 capable device.
for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
D3D_DRIVER_TYPE driverType = driverTypes[driverTypeIndex];
IDXGIAdapter* adapter;
for (UINT i = 0;
factory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND;
++i)
{
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
std::wstring adapterDesc(desc.Description);
hr = D3D11CreateDevice(adapter, driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &_Device, &usedFeatureLevel, &_ImmediateContext);
if (SUCCEEDED(hr))
{
wprintf(L"D3D is using: %s\n", adapterDesc.c_str());
break;
}
}
if (!_Device) {
printf("Couldn't create DirectX device.\nMaybe DirectX 11 is not supported on your machine?\n");
exit(-1);
}
if (adapter) adapter->Release();
if (SUCCEEDED(hr))
break;
}
factory->Release();
}
GPA_Status DX12GetAdapterDesc(IUnknown* pDevice, DXGI_ADAPTER_DESC& adapterDesc)
{
GPA_Status status = GPA_STATUS_OK;
if (nullptr == pDevice)
{
GPA_LogError("Parameter 'pDevice' is NULL.");
status = GPA_STATUS_ERROR_NULL_POINTER;
}
else
{
ID3D12Device* dx12Device = static_cast<ID3D12Device*>(pDevice);
LUID adapterLuid = dx12Device->GetAdapterLuid();
IDXGIFactory* pDXGIFactory = nullptr;
HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&pDXGIFactory));
if (FAILED(hr) || (nullptr == pDXGIFactory))
{
GPA_LogError("Unable to get IDXGIFactory interface from ID3D12Device.");
status = GPA_STATUS_ERROR_FAILED;
}
else
{
IDXGIAdapter* pAdapter = nullptr;
for (UINT index = 0; pDXGIFactory->EnumAdapters(index, &pAdapter) != DXGI_ERROR_NOT_FOUND; ++index)
{
memset(&adapterDesc, 0, sizeof(adapterDesc));
hr = pAdapter->GetDesc(&adapterDesc);
if (FAILED(hr))
{
GPA_LogError("Could not get adapter description, hardware cannot be supported.");
status = GPA_STATUS_ERROR_FAILED;
}
else
{
if (adapterDesc.AdapterLuid.HighPart == adapterLuid.HighPart && adapterDesc.AdapterLuid.LowPart == adapterLuid.LowPart)
{
// We found the matching adapter luid, so we're done.
break;
}
}
}
}
pDXGIFactory->Release();
}
return status;
}
void main()
{
//allows you to generate DXGI objects? at least that is what the documentation says.
//also not sure why the fourth version works but not the first
IDXGIFactory4* factory = nullptr;
HRESULT hr= CreateDXGIFactory1(IID_PPV_ARGS(&factory));
if (FAILED(hr))
{
cout << "Failed" << endl;
exit(1);
}
//this will contain about the cards that can render
IDXGIAdapter* adapter = nullptr;
UINT i = 0;
vector<IDXGIAdapter*> adapterList;
while (factory->EnumAdapters(i,&adapter) != DXGI_ERROR_NOT_FOUND)
{
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
wstring text = L"Adapter: ";
text += desc.Description;
text += L"\n";
wcout << text.c_str() << endl;
LogAdapterOutputs(adapter);
adapterList.push_back(adapter);
i++;
}
for (auto adapter : adapterList)
{
adapter->Release();
adapter = nullptr;
}
factory->Release();
factory = nullptr;
system("pause");
}
bool CDuplicateOutputDx11::Init()
{
HRESULT err = NULL;
DXGI_SWAP_CHAIN_DESC swapDesc;
ZeroMemory(&swapDesc, sizeof(swapDesc));
swapDesc.BufferCount = 2;
swapDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapDesc.BufferDesc.Width = 1920;
swapDesc.BufferDesc.Height = 1080;
swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapDesc.OutputWindow = m_hwnd;
swapDesc.SampleDesc.Count = 1;
swapDesc.Windowed = TRUE;
D3D_FEATURE_LEVEL desiredLevels[6] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1,
};
D3D_FEATURE_LEVEL receivedLevel;
D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_HARDWARE;
UINT flags = 0;//D3D11_CREATE_DEVICE_DEBUG;
//err = D3D11CreateDeviceAndSwapChain(pAdapter, driverType, NULL, flags, desiredLevels, 6, D3D11_SDK_VERSION, &swapDesc, &m_pSwapChain, &m_pDevice, &receivedLevel, &m_pDeviceContext);
IDXGIAdapter* pAdapter = NULL;
GetSpecificAdapter(0, &pAdapter);
DXGI_ADAPTER_DESC adapterDesc;
pAdapter->GetDesc(&adapterDesc);
err = D3D11CreateDeviceAndSwapChain(pAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, flags, desiredLevels, 6, D3D11_SDK_VERSION, &swapDesc, &m_pSwapChain, &m_pDevice, &receivedLevel, &m_pDeviceContext);
if (SUCCEEDED(err))
{
//m_pSwapChain->AddRef();
//m_pDevice->AddRef();
//m_pDeviceContext->AddRef();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
void EnumerateUsingDXGI( IDXGIFactory* pDXGIFactory )
{
assert( pDXGIFactory != 0 );
for( UINT index = 0; ; ++index )
{
IDXGIAdapter* pAdapter = nullptr;
HRESULT hr = pDXGIFactory->EnumAdapters( index, &pAdapter );
if( FAILED( hr ) ) // DXGIERR_NOT_FOUND is expected when the end of the list is hit
break;
DXGI_ADAPTER_DESC desc;
memset( &desc, 0, sizeof( DXGI_ADAPTER_DESC ) );
if( SUCCEEDED( pAdapter->GetDesc( &desc ) ) )
{
wprintf( L"\nDXGI Adapter: %u\nDescription: %s\n", index, desc.Description );
for( UINT iOutput = 0; ; ++iOutput )
{
IDXGIOutput* pOutput = nullptr;
hr = pAdapter->EnumOutputs( iOutput, &pOutput );
if( FAILED( hr ) ) // DXGIERR_NOT_FOUND is expected when the end of the list is hit
break;
DXGI_OUTPUT_DESC outputDesc;
memset( &outputDesc, 0, sizeof( DXGI_OUTPUT_DESC ) );
if( SUCCEEDED( pOutput->GetDesc( &outputDesc ) ) )
{
wprintf( L"hMonitor: 0x%0.8Ix\n", ( DWORD_PTR )outputDesc.Monitor );
wprintf( L"hMonitor Device Name: %s\n", outputDesc.DeviceName );
}
SAFE_RELEASE( pOutput );
}
wprintf(
L"\tGetVideoMemoryViaDXGI\n\t\tDedicatedVideoMemory: %Iu MB (%Iu)\n\t\tDedicatedSystemMemory: %Iu MB (%Iu)\n\t\tSharedSystemMemory: %Iu MB (%Iu)\n",
desc.DedicatedVideoMemory / 1024 / 1024, desc.DedicatedVideoMemory,
desc.DedicatedSystemMemory / 1024 / 1024, desc.DedicatedSystemMemory,
desc.SharedSystemMemory / 1024 / 1024, desc.SharedSystemMemory );
}
SAFE_RELEASE( pAdapter );
}
}
size_t
DXGI::GetAdapterPool (DXGI::GPUMemoryPool pool)
{
if (! NVAPI::CountPhysicalGPUs ()) {
IDXGIFactory* pFactory = NULL;
CreateDXGIFactory (__uuidof(IDXGIFactory), (void **)&pFactory);
IDXGIAdapter * pDXGIAdapter;
for (UINT i = 0; pFactory->EnumAdapters (i, &pDXGIAdapter) != DXGI_ERROR_NOT_FOUND; ++i) {
DXGI_ADAPTER_DESC adapterDesc;
pDXGIAdapter->GetDesc (&adapterDesc);
// Skip Microsoft's virtual adapters...
if (adapterDesc.VendorId != 0x1414) {
pDXGIAdapter->Release ();
pFactory->Release ();
if (pool == GART)
return adapterDesc.SharedSystemMemory;
else
return adapterDesc.DedicatedVideoMemory;
}
pDXGIAdapter->Release ();
}
pFactory->Release ();
}
else {
DXGI_ADAPTER_DESC* adapter_descs = NVAPI::EnumGPUs_DXGI ();
int i = 0;
while (*adapter_descs [i].Description != L'\0') {
if (pool == GART)
return adapter_descs [i].SharedSystemMemory;
else
return adapter_descs [i].DedicatedVideoMemory;
}
}
return 0;
}
bool WMIVideoInfo::_queryPropertyDXGI( const PVIQueryType queryType, const U32 adapterId, String *outValue )
{
#if 0
if( mDXGIFactory )
{
IDXGIAdapter* adapter;
if( mDXGIFactory->EnumAdapters( adapterId, &adapter ) != S_OK )
return false;
DXGI_ADAPTER_DESC desc;
if( adapter->GetDesc( &desc ) != S_OK )
{
adapter->Release();
return false;
}
String value;
switch( queryType )
{
case PVI_Description:
value = String( desc.Description );
break;
case PVI_Name:
value = String( avar( "%i", desc.DeviceId ) );
break;
case PVI_VRAM:
value = String( avar( "%i", desc.DedicatedVideoMemory / 1048576 ) );
break;
//RDTODO
}
adapter->Release();
*outValue = value;
return true;
}
#endif
return false;
}
Bool CImplDirectXGraphicsManager::Initialize( CGraphicsManager& manager )
{
m_PublicInterface = &manager;
UInt32 flags = 0;
IDXGIAdapter* selectedAdapter = NULL;
D3D10_DRIVER_TYPE driverType = D3D10_DRIVER_TYPE_HARDWARE;
#ifdef SETUP_CONFIG_DEBUG
flags = D3D10_CREATE_DEVICE_DEBUG;
#endif
AssertDXCall( D3D10CreateDevice( selectedAdapter,
driverType,
NULL,
flags,
D3D10_SDK_VERSION,
&m_Device ) );
#ifdef SETUP_CONFIG_DEBUG
IDXGIDevice * pDXGIDevice;
IDXGIAdapter * pDXGIAdapter;
AssertDXCall( m_Device->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice) );
AssertDXCall( pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&pDXGIAdapter) );
DXGI_ADAPTER_DESC desc;
pDXGIAdapter->GetDesc( &desc );
Char description[256];
WStringToString( desc.Description, description, 256 );
DebugLogInfo("-----------------------------");
DebugLogInfo("Description: %s", description );
DebugLogInfo("DedicatedVideoMemory: %f mo", desc.DedicatedVideoMemory / 1024.0f / 1024.0f );
DebugLogInfo("DedicatedSystemMemory: %f mo", desc.DedicatedSystemMemory / 1024.0f / 1024.0f );
DebugLogInfo("SharedSystemMemory: %f mo", desc.SharedSystemMemory / 1024.0f / 1024.0f );
DebugLogInfo("-----------------------------");
#endif
return TRUE;
}
IDXGIAdapter* CDXGIManager::EnumAdapters( HWND hWND)
{
IDXGIFactory* pFactory;
HRESULT hr = CreateDXGIFactory( IID_IDXGIFactory, (void**)&pFactory );
if( FAILED(hr) )
{
MessageBox( hWND, L"Cambia de computadora", L"Error Fatal", MB_ICONERROR );
return NULL;
}
int iAdapter = 0;
IDXGIAdapter* pAdapter = 0;
while(1)
{
DXGI_ADAPTER_DESC dad;
if( FAILED( pFactory->EnumAdapters( iAdapter, &pAdapter) ) )
break;
TCHAR szMessage[ 1024 ];
pAdapter->GetDesc( &dad );
wsprintf( szMessage, L"Description: %s\r\nDedicated Memory: %d MB\r\nShared Memory: %d MB\r\nSystem Memory: %d",
dad.Description,
dad.DedicatedVideoMemory /(1024*1024),
dad.SharedSystemMemory /(1024*1024),
dad.DedicatedSystemMemory /(1024*1024) );
switch( MessageBox( hWND, szMessage, L"Do you wish to use this device?",
MB_YESNOCANCEL | MB_ICONQUESTION ) )
{
case IDYES:
SAFE_RELEASE( pFactory );
return pAdapter;
case IDNO:
break;
case IDCANCEL:
SAFE_RELEASE( pFactory );
SAFE_RELEASE( pAdapter );
return NULL;
}
iAdapter++;
}
}
bool D3D::Init(int screenWidth, int screenHeight, bool vsync, HWND hWnd, bool fullscreen, float screenDepth, float screenNear)
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
D3D11_BLEND_DESC blendStateDesc;
// Store the vsync setting.
_vsyncEnabled = vsync;
//Create a DirectX graphics interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
return false;
//Use the factory to create an adpater for the primary graphics interface (video card)
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
return false;
//Enumerate the primary adapter output (monitor)
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
return false;
//Get the number of modes that fix the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor)
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
return false;
//Create a list to hold all the possible display modes for this monitor/video card combination
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
return false;
//Now fill the display mode list structures
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
return false;
//Now go through all the displa modes and find the one that matches the screen width and height
//When a match is found store the numerator and denominator of the refresh rate for that monitor
for (i=0; i<numModes; ++i)
{
if (displayModeList[i].Width == (unsigned int) screenWidth)
{
if (displayModeList[i].Height == (unsigned int) screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
//Get the adapter (video card) description
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
return false;
//Store the dedicated video card memory in mb
_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//Convert eh name of the video card to a char array and store
error = wcstombs_s(&stringLength, _videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
return false;
//Release the display mode list
delete[] displayModeList;
displayModeList = NULL;
//Release the adapter output
adapterOutput->Release();
adapterOutput = NULL;
//release the adapater
adapter->Release();
adapter = NULL;
//Release the factory
factory->Release();
factory = NULL;
//Init the swap chain description
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
//Set to a single back buffer
swapChainDesc.BufferCount = 1;
//Set the width and height of the back buffer
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
//Set regular 32 bit surface for the back buffer
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
//Set the refresh rate of the back buffer
if(_vsyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
//Set the usage of the back buffer
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
//Set the handle for the window to render to
swapChainDesc.OutputWindow = hWnd;
//Turn multisampling off
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
//Set to fullscreen/windows
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
//Set the scan line ordering and scaling to unspecified
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//Discard the back buffer contents after preseting
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
//Create the swap chain, Direct3D device, and device context
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &_swapChain, &_device, NULL, &_deviceContext);
if (FAILED(result))
return false;
//Get the pointer to the back buffer
result = _swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
return false;
//Create the render target view with the back buffer pointer
result = _device->CreateRenderTargetView(backBufferPtr, NULL, &_renderTargetView);
if (FAILED(result))
return false;
//Release pointer to the back buffer as we no longer need it
backBufferPtr->Release();
backBufferPtr = NULL;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = _device->CreateTexture2D(&depthBufferDesc, NULL, &_depthStencilBuffer);
if(FAILED(result))
return false;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the depth stencil state.
result = _device->CreateDepthStencilState(&depthStencilDesc, &_depthStencilState);
if(FAILED(result))
return false;
//Set the depth stencil state
_deviceContext->OMSetDepthStencilState(_depthStencilState, 1);
//Init the depth stencil view
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
//Set up the depth stencil view desc
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = _device->CreateDepthStencilView(_depthStencilBuffer, &depthStencilViewDesc, &_depthStencilView);
if(FAILED(result))
return false;
// Bind the render target view and depth stencil buffer to the output render pipeline.
_deviceContext->OMSetRenderTargets(1, &_renderTargetView, _depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = _device->CreateRasterizerState(&rasterDesc, &_rasterState);
if(FAILED(result))
{
return false;
}
// Now set the rasterizer state.
_deviceContext->RSSetState(_rasterState);
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
_deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&_worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
//Clear the second depth stencil state before setting params
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering. The only difference is
// that DepthEnable is set to false, all other parameters are the same as the other depth stencil state.
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//Create the state using the device
result = _device->CreateDepthStencilState(&depthDisabledStencilDesc, &_depthDisabledStencilState);
if (FAILED(result))
return false;
//Clear the blend state desc
ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC));
// Create an alpha enabled blend state description.
blendStateDesc.RenderTarget[0].BlendEnable = TRUE;
blendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
//Create the blend state using the desciption
result = _device->CreateBlendState(&blendStateDesc, &_aEnableBlendingState);
if (FAILED(result))
return false;
//Modify the desciption to create an alpha disabled blend state desc
blendStateDesc.RenderTarget[0].BlendEnable = FALSE;
//Create the blend state using the desc
result = _device->CreateBlendState(&blendStateDesc, &_aDisableBlendingState);
if (FAILED(result))
return false;
return true;
}
void InitBackendInfo()
{
HRESULT hr = DX11::D3D::LoadDXGI();
if (SUCCEEDED(hr)) hr = DX11::D3D::LoadD3D();
if (FAILED(hr))
{
DX11::D3D::UnloadDXGI();
return;
}
g_Config.backend_info.APIType = API_D3D;
g_Config.backend_info.bUseRGBATextures = true; // the GX formats barely match any D3D11 formats
g_Config.backend_info.bUseMinimalMipCount = true;
g_Config.backend_info.bSupportsExclusiveFullscreen = true;
g_Config.backend_info.bSupportsDualSourceBlend = true;
g_Config.backend_info.bSupportsPrimitiveRestart = true;
g_Config.backend_info.bSupportsOversizedViewports = false;
IDXGIFactory* factory;
IDXGIAdapter* ad;
hr = DX11::PCreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(hr))
PanicAlert("Failed to create IDXGIFactory object");
// 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)
{
const size_t adapter_index = g_Config.backend_info.Adapters.size();
DXGI_ADAPTER_DESC desc;
ad->GetDesc(&desc);
// TODO: These don't get updated on adapter change, yet
if (adapter_index == g_Config.iAdapter)
{
std::string samples;
std::vector<DXGI_SAMPLE_DESC> modes = DX11::D3D::EnumAAModes(ad);
for (unsigned int i = 0; i < modes.size(); ++i)
{
if (i == 0)
samples = _trans("None");
else if (modes[i].Quality)
samples = StringFromFormat(_trans("%d samples (quality level %d)"), modes[i].Count, modes[i].Quality);
else
samples = StringFromFormat(_trans("%d samples"), modes[i].Count);
g_Config.backend_info.AAModes.push_back(samples);
}
// Requires the earlydepthstencil attribute (only available in shader model 5)
g_Config.backend_info.bSupportsEarlyZ = (DX11::D3D::GetFeatureLevel(ad) == D3D_FEATURE_LEVEL_11_0);
}
g_Config.backend_info.Adapters.push_back(UTF16ToUTF8(desc.Description));
ad->Release();
}
factory->Release();
// Clear ppshaders string vector
g_Config.backend_info.PPShaders.clear();
DX11::D3D::UnloadDXGI();
DX11::D3D::UnloadD3D();
}
NS_DECL_ISUPPORTS
// nsIMemoryMultiReporter abstract method implementation
NS_IMETHOD
CollectReports(nsIMemoryMultiReporterCallback* aCb,
nsISupports* aClosure)
{
PRInt32 winVers, buildNum;
HANDLE ProcessHandle = GetCurrentProcess();
PRInt64 dedicatedBytesUsed = 0;
PRInt64 sharedBytesUsed = 0;
PRInt64 committedBytesUsed = 0;
IDXGIAdapter *DXGIAdapter;
HMODULE gdi32Handle;
PFND3DKMT_QUERYSTATISTICS queryD3DKMTStatistics;
winVers = gfxWindowsPlatform::WindowsOSVersion(&buildNum);
// GPU memory reporting is not available before Windows 7
if (winVers < gfxWindowsPlatform::kWindows7)
return NS_OK;
if (gdi32Handle = LoadLibrary(TEXT("gdi32.dll")))
queryD3DKMTStatistics = (PFND3DKMT_QUERYSTATISTICS)GetProcAddress(gdi32Handle, "D3DKMTQueryStatistics");
if (queryD3DKMTStatistics && GetDXGIAdapter(&DXGIAdapter)) {
// Most of this block is understood thanks to wj32's work on Process Hacker
DXGI_ADAPTER_DESC adapterDesc;
D3DKMT_QUERYSTATISTICS queryStatistics;
DXGIAdapter->GetDesc(&adapterDesc);
DXGIAdapter->Release();
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_PROCESS;
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
queryStatistics.hProcess = ProcessHandle;
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
committedBytesUsed = queryStatistics.QueryResult.ProcessInformation.SystemMemory.BytesAllocated;
}
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_ADAPTER;
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
ULONG i;
ULONG segmentCount = queryStatistics.QueryResult.AdapterInformation.NbSegments;
for (i = 0; i < segmentCount; i++) {
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_SEGMENT;
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
queryStatistics.QuerySegment.SegmentId = i;
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
bool aperture;
// SegmentInformation has a different definition in Win7 than later versions
if (winVers > gfxWindowsPlatform::kWindows7)
aperture = queryStatistics.QueryResult.SegmentInformation.Aperture;
else
aperture = queryStatistics.QueryResult.SegmentInformationV1.Aperture;
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT;
queryStatistics.AdapterLuid = adapterDesc.AdapterLuid;
queryStatistics.hProcess = ProcessHandle;
queryStatistics.QueryProcessSegment.SegmentId = i;
if (NT_SUCCESS(queryD3DKMTStatistics(&queryStatistics))) {
if (aperture)
sharedBytesUsed += queryStatistics.QueryResult
.ProcessSegmentInformation
.BytesCommitted;
else
dedicatedBytesUsed += queryStatistics.QueryResult
.ProcessSegmentInformation
.BytesCommitted;
}
}
}
}
}
FreeLibrary(gdi32Handle);
#define REPORT(_path, _amount, _desc) \
do { \
nsresult rv; \
rv = aCb->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
nsIMemoryReporter::KIND_OTHER, \
nsIMemoryReporter::UNITS_BYTES, _amount, \
NS_LITERAL_CSTRING(_desc), aClosure); \
NS_ENSURE_SUCCESS(rv, rv); \
} while (0)
REPORT("gpu-committed", committedBytesUsed,
"Memory committed by the Windows graphics system.");
REPORT("gpu-dedicated", dedicatedBytesUsed,
"Out-of-process memory allocated for this process in a "
"physical GPU adapter's memory.");
REPORT("gpu-shared", sharedBytesUsed,
"In-process memory that is shared with the GPU.");
#undef REPORT
return NS_OK;
}
HRESULT ACD3D::CreateGraphicsDevice(int width, int height)
{
HRESULT hr;
Log("Begin Init Graphics Device");
//inicializa membros
mDriverType = D3D_DRIVER_TYPE_HARDWARE;
mFeatureLevel = D3D_FEATURE_LEVEL_11_0;
ACD3DGlobals::G_pD3dDevice = nullptr;
ACD3DGlobals::G_pContext = nullptr;
//tipo de dispositivo debug ou release
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE( driverTypes );
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
UINT numFeatureLevels = ARRAYSIZE( featureLevels );
//********************************
// cria do dispositivo grafico
//********************************
for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
{
mDriverType = driverTypes[driverTypeIndex];
//passa null no adapter ai ele cria automatico, depois eu recupero para pegar algumas configuracoes
hr = D3D11CreateDevice(nullptr, mDriverType, nullptr, createDeviceFlags, featureLevels,
numFeatureLevels, D3D11_SDK_VERSION, &ACD3DGlobals::G_pD3dDevice,
&mFeatureLevel, &ACD3DGlobals::G_pContext );
if( SUCCEEDED( hr ) )
{
Log("Create graphics device success.");
break;
}
}
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create device error. D3DCreateDevice()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
//*********************************
// fim da criacao do dispositivo grafico
//*********************************
IDXGIFactory* pDXGIFactory = ACD3DTools::GetDXGIFactory();
IDXGIAdapter* pDXGIAdapter = ACD3DTools::GetDXGIAdapter();
//usando os objetos acima ele retorna algumas configuracoes
IDXGIOutput* pAdapterOutput;
unsigned int numModes, i, stringLength;
DXGI_MODE_DESC* pDisplayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
// Enumerate the primary adapter output (monitor).
hr = pDXGIAdapter->EnumOutputs(0, &pAdapterOutput);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] EnumOutputs. D3DCreateDevice()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
hr = pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] GetDisplayModeList", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
pDisplayModeList = new DXGI_MODE_DESC[numModes];
if(!pDisplayModeList)
return AC_FAIL;
// Now fill the display mode list structures.
hr = pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, pDisplayModeList);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] GetDisplayModeList", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for(i=0; i<numModes; i++)
{
if(pDisplayModeList[i].Width == (unsigned int)width)
{
if(pDisplayModeList[i].Height == (unsigned int)height)
{
ACD3DGlobals::G_Numerator = pDisplayModeList[i].RefreshRate.Numerator;
ACD3DGlobals::G_Denomerator = pDisplayModeList[i].RefreshRate.Denominator;
}
}
}
Log("Width: %i. Height: %i", width, height);
// Get the adapter (video card) description.
hr = pDXGIAdapter->GetDesc(&adapterDesc);
if(FAILED(hr))
return hr;
// Store the dedicated video card memory in megabytes.
VideoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
Log("VideoCardMemory: %i (in megabytes).", VideoCardMemory);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, VideoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
Log("[ERROR] Get videocarddescription.");
return AC_FAIL;
}
// Release the display mode list.
SAFE_DELETE_A(pDisplayModeList);
// Release the adapter output.
pAdapterOutput->Release();
pAdapterOutput = nullptr;
// Release the adapter.
pDXGIAdapter->Release();
pDXGIAdapter = nullptr;
// Release the factory.
pDXGIFactory->Release();
pDXGIFactory = nullptr;
Log("End Graphics Device");
return AC_OK;
};
bool DX11::CreateDevice(HWND a_hwnd)
{
HRESULT result;
// Create a DirectX graphics interface factory.
IDXGIFactory* factory;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**) &factory);
if (FAILED(result))
{
LOG_ERROR("Could not create DXGI Factory.");
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
IDXGIAdapter* adapter;
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
LOG_ERROR("Could not create graphics adapter.");
return false;
}
// Enumerate the primary adapter output (monitor).
IDXGIOutput* adapterOutput;
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
LOG_ERROR("Could not create graphics adapter output.");
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
unsigned int displaymodes;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &displaymodes, NULL);
if (FAILED(result))
{
LOG_ERROR("Could not create display mode list.");
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[displaymodes];
if (!displayModeList)
{
LOG_ERROR("Could not fill display mode list.");
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &displaymodes, displayModeList);
if (FAILED(result))
{
LOG_ERROR("Could not fill display mode list structures.");
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
unsigned int numerator;
unsigned int denominator;
for (unsigned int i = 0; i < displaymodes; i++)
{
if (displayModeList[i].Width == (unsigned int) m_width)
{
if (displayModeList[i].Height == (unsigned int) m_height)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
LOG_ERROR("Could not get graphics device description.");
return false;
}
// Store the dedicated video card memory in megabytes.
m_vmemory = (int) (adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
unsigned int stringLength;
int error = wcstombs_s(&stringLength, m_cardDesc, 128, adapterDesc.Description, 128);
if (error != 0)
{
LOG_ERROR("Could not get graphics device name.");
return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release resources.
RELEASE(adapterOutput);
RELEASE(adapter);
RELEASE(factory);
// Initialize the swap chain description.
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = (UINT) (m_width * m_renderScale);
swapChainDesc.BufferDesc.Height = (UINT) (m_height * m_renderScale);
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if (m_vsync)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = a_hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
swapChainDesc.Windowed = (m_fullscreen) ? false : true;
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Create the swap chain, Direct3D device, and Direct3D device context.
#if defined(_DEBUG)
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG | D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS, NULL, NULL,
D3D11_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pDevice, NULL, &m_pDeviceContext);
#else
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, NULL, NULL,
D3D11_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pDevice, NULL, &m_pDeviceContext);
#endif
if (FAILED(result))
{
LOG_ERROR("Could not create D3D11 device, device context and swap chain.");
return false;
}
// Get the pointer to the back buffer.
result = m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*) &m_pBackBuffer);
if (FAILED(result))
{
LOG_ERROR("Could not get back buffer.");
return false;
}
#if defined(_DEBUG)
result = m_pDevice->QueryInterface(__uuidof(ID3D11Debug), (LPVOID*) &m_pDebug);
if (FAILED(result))
{
LOG_ERROR("Could not create debug interface.");
return false;
}
#endif
return true;
}
bool D3DApp::InitGraphicsCard()
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes = 0;
unsigned int numerator = 0;
unsigned int denomenator = 0;
unsigned int stringLength = 0;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
//Create Direct x graphic interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
//use factory now
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result)){ return false; }
//enumerate the primary output (monitor)
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
//Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the monitor
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
//Create a list to hold all the modes for the monitor/video card combo
displayModeList = new DXGI_MODE_DESC[numModes];
//fill the list
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
//Loop through the whole list finding what one equals screen width / height
for (int i = 0; i < numModes; ++i)
{
if (displayModeList[i].Width == (unsigned int)m_ScreenWidth)
{
if (displayModeList[i].Height == (unsigned int)m_ScreenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denomenator = displayModeList[i].RefreshRate.Denominator;
m_MonitorDenumerator = numerator;
m_MonitorNumerator = denomenator;
}
}
}
if (numerator == 0 && denomenator == 0)
{
return false;
}
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
//Store video car memory in MBs
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//Convert the name of the car to a char array
error = wcstombs_s(&stringLength, m_pVideoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
//Release memory
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
return true;
}
void EnableDrawing (HGLRC *hRC) {
WindowResizedCallback = &WindowResized;
d3dmgr = new ContextManager();
int screenWidth = window_get_width(),
screenHeight = window_get_height();
screenWidth = screenWidth <= 0 ? 1 : screenWidth;
screenHeight = screenHeight <= 0 ? 1 : screenHeight;
bool vsync = false;
HWND hwnd = enigma::hWnd;
bool fullscreen = false;
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
// Store the vsync setting.
m_vsync_enabled = vsync;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
{
//return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
{
//return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
{
//return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
{
//return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
//return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
{
//return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for(i=0; i<numModes; i++)
{
if(displayModeList[i].Width == (unsigned int)screenWidth)
{
if(displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
{
//return false;
}
// Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
//error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
//return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if(FAILED(result))
{
//return false;
}
// Get the pointer to the back buffer.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
{
//return false;
}
// Create the render target view with the back buffer pointer.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
{
//return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
//return false;
}
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
{
//return false;
}
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// Initailze the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
//return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
{
//return false;
}
// Now set the rasterizer state.
m_deviceContext->RSSetState(m_rasterState);
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
}
void Renderer::init_device(Window &window)
{
// Set default adapter and driver type settings
IDXGIAdapter* adapter_to_use = nullptr;
D3D_DRIVER_TYPE driver_type = D3D_DRIVER_TYPE_HARDWARE;
// Look for 'NVIDIA PerfHUD' adapter
// If it is present, override default settings
IDXGIFactory * dxgi_factory = nullptr;
if (FAILED( CreateDXGIFactory(IID_PPV_ARGS(&dxgi_factory)) ) )
throw RendererInitError("CreateDXGIFactory");
unsigned i = 0;
IDXGIAdapter * adapter = nullptr;
while(dxgi_factory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND)
{
DXGI_ADAPTER_DESC desc;
if( FAILED( adapter->GetDesc(&desc) ) )
throw RendererInitError("IDXGIAdapter::GetDesc");
if (wcsstr(desc.Description, L"PerfHUD") != 0)
{
adapter_to_use = adapter;
driver_type = D3D_DRIVER_TYPE_REFERENCE;
break;
} else {
release_interface(adapter);
}
++i;
}
// TODO !!!!! Release all interfaces, including when throwing an exception!
// Use ComPtr or CComPtr or something like these?
// Create the device
D3D_FEATURE_LEVEL feature_levels[] = {
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0 // we need at least feature level 10 for geometry shader
};
unsigned feature_levels_count = array_size(feature_levels);
unsigned device_flags = 0;
#ifndef NDEBUG
device_flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif //ifndef NDEBUG
if (FAILED( D3D11CreateDevice(adapter_to_use,
driver_type,
nullptr, // no software module
device_flags,
feature_levels,
feature_levels_count,
D3D11_SDK_VERSION,
&device,
nullptr, // do not care which feature level was selected
&context)))
throw RendererInitError("D3D11CreateDevice");
release_interface(adapter_to_use);
// Create swap chain. Used defaults from https://hieroglyph3.codeplex.com/SourceControl/latest#trunk/Hieroglyph3/Source/SwapChainConfigDX11.cpp
DXGI_SWAP_CHAIN_DESC swap_chain_desc;
swap_chain_desc.BufferDesc.Width = window.get_width();
swap_chain_desc.BufferDesc.Height = window.get_height();
swap_chain_desc.BufferDesc.RefreshRate.Numerator = 60;
swap_chain_desc.BufferDesc.RefreshRate.Denominator = 1;
swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
swap_chain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swap_chain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_STRETCHED;
swap_chain_desc.SampleDesc.Count = 1;
swap_chain_desc.SampleDesc.Quality = 0;
swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swap_chain_desc.BufferCount = 2;
swap_chain_desc.OutputWindow = window;
swap_chain_desc.Windowed = true;
swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swap_chain_desc.Flags = 0;
if ( FAILED(dxgi_factory->CreateSwapChain(device, &swap_chain_desc, &swap_chain) ) )
throw RendererInitError("IDXGIFactory::CreateSwapChain");
release_interface(dxgi_factory);
// Create a render target view for a back buffer
ID3D11Texture2D *back_buffer = nullptr;
if ( FAILED( swap_chain->GetBuffer( 0, IID_PPV_ARGS(&back_buffer) ) ) )
throw RendererInitError("IDXGISwapChain::GetBuffer");
if ( FAILED( device->CreateRenderTargetView(back_buffer, nullptr, &render_target_view) ) )
throw RendererInitError("ID3D11Device::CreateRenderTargetView");
release_interface(back_buffer);
// Create a depth stencil view. Use defaults from the book Practical Rendering and Computation with Direct3D 11, page 22
D3D11_TEXTURE2D_DESC depth_buffer_desc;
depth_buffer_desc.Width = window.get_width();
depth_buffer_desc.Height = window.get_height();
depth_buffer_desc.MipLevels = 1;
depth_buffer_desc.ArraySize = 1;
depth_buffer_desc.Format = DXGI_FORMAT_D32_FLOAT;
depth_buffer_desc.SampleDesc = swap_chain_desc.SampleDesc; // use the same defaults as we used above for swap chain
depth_buffer_desc.Usage = D3D11_USAGE_DEFAULT;
depth_buffer_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depth_buffer_desc.CPUAccessFlags = 0;
depth_buffer_desc.MiscFlags = 0;
ID3D11Texture2D *depth_buffer = nullptr;
if ( FAILED( device->CreateTexture2D(&depth_buffer_desc, nullptr, &depth_buffer) ) )
throw RendererInitError("ID3D11Device::CreateTexture2D(depth_buffer)");;
if ( FAILED( device->CreateDepthStencilView(depth_buffer, nullptr, &depth_stencil_view) ) )
throw RendererInitError("ID3D11Device::CreateDepthStencilView");
release_interface(depth_buffer);
// Now set render target view and depth stencil view
ID3D11RenderTargetView * rt_views[] = {render_target_view};
context->OMSetRenderTargets(array_size(rt_views), rt_views, depth_stencil_view);
// Set viewport
D3D11_VIEWPORT vp;
vp.Width = static_cast<FLOAT>(window.get_width());
vp.Height = static_cast<FLOAT>(window.get_height());
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
context->RSSetViewports( 1, &vp );
// Configure alpha-test
// TODO: [DX11] enable alpha test (no direct equivalent for D3DRS_ALPHAREF and D3DRS_ALPHATESTENABLE
#pragma WARNING(DX11 porting unfinished: alpha test)
// Configure alpha-blending
D3D11_BLEND_DESC blendDesc;
blendDesc.AlphaToCoverageEnable = FALSE;
blendDesc.IndependentBlendEnable = FALSE;
blendDesc.RenderTarget[0].BlendEnable = TRUE;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; // resulting alpha value is not important, so use defaults
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
ID3D11BlendState * blendState = nullptr;
check_state( device->CreateBlendState(&blendDesc, &blendState) );
context->OMSetBlendState(blendState, nullptr, 0xffffff);
release_interface(blendState);
// Prepare states for wireframe toggling
D3D11_RASTERIZER_DESC rs_desc;
rs_desc.FillMode = D3D11_FILL_SOLID;
rs_desc.CullMode = D3D11_CULL_BACK;
rs_desc.FrontCounterClockwise = false;
rs_desc.DepthBias = 0;
rs_desc.DepthBiasClamp = 0;
rs_desc.SlopeScaledDepthBias = 0;
rs_desc.DepthClipEnable = true;
rs_desc.ScissorEnable = false;
rs_desc.MultisampleEnable = false;
rs_desc.AntialiasedLineEnable = false;
check_state( device->CreateRasterizerState(&rs_desc, &rs_wireframe_off) );
rs_desc.FillMode = D3D11_FILL_WIREFRAME;
check_state( device->CreateRasterizerState(&rs_desc, &rs_wireframe_on) );
set_wireframe(INITIAL_WIREFRAME_STATE);
set_alpha_test();
}
void VideoBackend::InitBackendInfo()
{
HRESULT hr = DX11::D3D::LoadDXGI();
if (SUCCEEDED(hr))
hr = DX11::D3D::LoadD3D();
if (FAILED(hr))
{
DX11::D3D::UnloadDXGI();
return;
}
g_Config.backend_info.api_type = APIType::D3D;
g_Config.backend_info.MaxTextureSize = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
g_Config.backend_info.bUsesLowerLeftOrigin = false;
g_Config.backend_info.bSupportsExclusiveFullscreen = true;
g_Config.backend_info.bSupportsDualSourceBlend = true;
g_Config.backend_info.bSupportsPrimitiveRestart = true;
g_Config.backend_info.bSupportsOversizedViewports = false;
g_Config.backend_info.bSupportsGeometryShaders = true;
g_Config.backend_info.bSupportsComputeShaders = false;
g_Config.backend_info.bSupports3DVision = true;
g_Config.backend_info.bSupportsPostProcessing = true;
g_Config.backend_info.bSupportsPaletteConversion = true;
g_Config.backend_info.bSupportsClipControl = true;
g_Config.backend_info.bSupportsDepthClamp = true;
g_Config.backend_info.bSupportsReversedDepthRange = false;
g_Config.backend_info.bSupportsLogicOp = true;
g_Config.backend_info.bSupportsMultithreading = false;
g_Config.backend_info.bSupportsGPUTextureDecoding = true;
g_Config.backend_info.bSupportsST3CTextures = false;
g_Config.backend_info.bSupportsCopyToVram = true;
g_Config.backend_info.bSupportsLargePoints = false;
g_Config.backend_info.bSupportsPartialDepthCopies = false;
g_Config.backend_info.bSupportsBitfield = false;
g_Config.backend_info.bSupportsDynamicSamplerIndexing = false;
g_Config.backend_info.bSupportsBPTCTextures = false;
g_Config.backend_info.bSupportsFramebufferFetch = false;
g_Config.backend_info.bSupportsBackgroundCompiling = true;
IDXGIFactory2* factory;
IDXGIAdapter* ad;
hr = DX11::PCreateDXGIFactory(__uuidof(IDXGIFactory2), (void**)&factory);
if (FAILED(hr))
PanicAlert("Failed to create IDXGIFactory object");
// 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)
{
const size_t adapter_index = g_Config.backend_info.Adapters.size();
DXGI_ADAPTER_DESC desc;
ad->GetDesc(&desc);
// TODO: These don't get updated on adapter change, yet
if (adapter_index == g_Config.iAdapter)
{
std::vector<DXGI_SAMPLE_DESC> modes = DX11::D3D::EnumAAModes(ad);
// First iteration will be 1. This equals no AA.
for (unsigned int i = 0; i < modes.size(); ++i)
{
g_Config.backend_info.AAModes.push_back(modes[i].Count);
}
D3D_FEATURE_LEVEL feature_level = D3D::GetFeatureLevel(ad);
bool shader_model_5_supported = feature_level >= D3D_FEATURE_LEVEL_11_0;
g_Config.backend_info.MaxTextureSize = D3D::GetMaxTextureSize(feature_level);
// Requires the earlydepthstencil attribute (only available in shader model 5)
g_Config.backend_info.bSupportsEarlyZ = shader_model_5_supported;
// Requires full UAV functionality (only available in shader model 5)
g_Config.backend_info.bSupportsBBox =
g_Config.backend_info.bSupportsFragmentStoresAndAtomics = shader_model_5_supported;
// Requires the instance attribute (only available in shader model 5)
g_Config.backend_info.bSupportsGSInstancing = shader_model_5_supported;
// Sample shading requires shader model 5
g_Config.backend_info.bSupportsSSAA = shader_model_5_supported;
}
g_Config.backend_info.Adapters.push_back(UTF16ToUTF8(desc.Description));
ad->Release();
}
factory->Release();
DX11::D3D::UnloadDXGI();
DX11::D3D::UnloadD3D();
}
void VideoBackend::InitBackendInfo()
{
HRESULT hr = D3D::LoadDXGI();
if (FAILED(hr))
return;
hr = D3D::LoadD3D();
if (FAILED(hr))
{
D3D::UnloadDXGI();
return;
}
g_Config.backend_info.api_type = APIType::D3D;
g_Config.backend_info.bSupportsExclusiveFullscreen = false;
g_Config.backend_info.bSupportsDualSourceBlend = true;
g_Config.backend_info.bSupportsPrimitiveRestart = true;
g_Config.backend_info.bSupportsOversizedViewports = false;
g_Config.backend_info.bSupportsGeometryShaders = true;
g_Config.backend_info.bSupports3DVision = true;
g_Config.backend_info.bSupportsPostProcessing = false;
g_Config.backend_info.bSupportsPaletteConversion = true;
g_Config.backend_info.bSupportsClipControl = true;
g_Config.backend_info.bSupportsDepthClamp = true;
g_Config.backend_info.bSupportsReversedDepthRange = false;
g_Config.backend_info.bSupportsMultithreading = false;
g_Config.backend_info.bSupportsInternalResolutionFrameDumps = false;
IDXGIFactory* factory;
IDXGIAdapter* ad;
hr = create_dxgi_factory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(hr))
{
PanicAlert("Failed to create IDXGIFactory object");
D3D::UnloadD3D();
D3D::UnloadDXGI();
return;
}
// 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)
{
const size_t adapter_index = g_Config.backend_info.Adapters.size();
DXGI_ADAPTER_DESC desc;
ad->GetDesc(&desc);
// TODO: These don't get updated on adapter change, yet
if (adapter_index == g_Config.iAdapter)
{
ID3D12Device* temp_device;
hr = d3d12_create_device(ad, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&temp_device));
if (SUCCEEDED(hr))
{
std::string samples;
std::vector<DXGI_SAMPLE_DESC> modes = D3D::EnumAAModes(temp_device);
// First iteration will be 1. This equals no AA.
for (unsigned int i = 0; i < modes.size(); ++i)
{
g_Config.backend_info.AAModes.push_back(modes[i].Count);
}
// Requires the earlydepthstencil attribute (only available in shader model 5)
g_Config.backend_info.bSupportsEarlyZ = true;
// Requires full UAV functionality (only available in shader model 5)
g_Config.backend_info.bSupportsBBox = true;
// Requires the instance attribute (only available in shader model 5)
g_Config.backend_info.bSupportsGSInstancing = true;
// Sample shading requires shader model 5
g_Config.backend_info.bSupportsSSAA = true;
temp_device->Release();
}
}
g_Config.backend_info.Adapters.push_back(UTF16ToUTF8(desc.Description));
ad->Release();
}
factory->Release();
// Clear ppshaders string vector
g_Config.backend_info.PPShaders.clear();
g_Config.backend_info.AnaglyphShaders.clear();
D3D::UnloadD3D();
D3D::UnloadDXGI();
}