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 DesktopDuplication::init() { IDXGIFactory1* dxgiFactory = nullptr; CHECKED(hr, CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory))); IDXGIAdapter1* dxgiAdapter = nullptr; CHECKED(hr, dxgiFactory->EnumAdapters1(adapter, &dxgiAdapter)); dxgiFactory->Release(); CHECKED(hr, D3D11CreateDevice(dxgiAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, NULL, NULL, NULL, D3D11_SDK_VERSION, &d3dDevice, NULL, &d3dContext)); IDXGIOutput* dxgiOutput = nullptr; CHECKED(hr, dxgiAdapter->EnumOutputs(output, &dxgiOutput)); dxgiAdapter->Release(); IDXGIOutput1* dxgiOutput1 = nullptr; CHECKED(hr, dxgiOutput->QueryInterface(__uuidof(dxgiOutput1), reinterpret_cast<void**>(&dxgiOutput1))); dxgiOutput->Release(); IDXGIDevice* dxgiDevice = nullptr; CHECKED(hr, d3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice))); CHECKED(hr, dxgiOutput1->DuplicateOutput(dxgiDevice, &outputDuplication)); dxgiOutput1->Release(); dxgiDevice->Release(); }
static inline void EnumD3DAdapters( bool (*callback)(void*, const char*, uint32_t), void *param) { ComPtr<IDXGIFactory1> factory; ComPtr<IDXGIAdapter1> adapter; HRESULT hr; UINT i = 0; IID factoryIID = (GetWinVer() >= 0x602) ? dxgiFactory2 : __uuidof(IDXGIFactory1); hr = CreateDXGIFactory1(factoryIID, (void**)factory.Assign()); if (FAILED(hr)) throw HRError("Failed to create DXGIFactory", hr); while (factory->EnumAdapters1(i++, adapter.Assign()) == S_OK) { DXGI_ADAPTER_DESC desc; char name[512] = ""; hr = adapter->GetDesc(&desc); if (FAILED(hr)) continue; /* ignore microsoft's 'basic' renderer' */ if (desc.VendorId == 0x1414 && desc.DeviceId == 0x8c) continue; os_wcs_to_utf8(desc.Description, 0, name, sizeof(name)); if (!callback(param, name, i - 1)) break; } }
IDXGIAdapter* spoutDirectX::GetAdapterPointer(int index) { // printf("spoutDirectX::GetAdapterPointer(%d)\n", index); // Enum Adapters first : multiple video cards IDXGIFactory1* _dxgi_factory1; if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) { printf( " Could not create CreateDXGIFactory1\n" ); return nullptr; } IDXGIAdapter* adapter1_ptr = nullptr; for ( UINT32 i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { if ( index == (int)i ) { // printf(" Adapter %d matches\n", i); // Now we have the requested adapter, but does it support the required extensions _dxgi_factory1->Release(); return adapter1_ptr; } else { // printf(" Adapter %d found\n", i); } adapter1_ptr->Release(); } // printf(" Adapter %d not found\n", index); _dxgi_factory1->Release(); return nullptr; }
bool CDuplicateOutputDx11::GetSpecificAdapter(int idAdapter, IDXGIAdapter** pAdapter) { HRESULT err = S_OK; if (!pAdapter) { return false; } REFIID iidVal = __uuidof(IDXGIFactory1); UINT adapterID = 0; // adapter index IDXGIFactory1* pFactory = NULL; if (FAILED(err = CreateDXGIFactory1(iidVal, (void**)&pFactory))) { return false; } UINT i = 0; UINT adapterDeviceID = idAdapter; // if device id equal zero, use the first device DXGI_ADAPTER_DESC dxgiDesc; IDXGIAdapter1 *giAdapter = NULL; if (pFactory->EnumAdapters1(i, &giAdapter) != S_OK) { return false; } if (pFactory)pFactory->Release(); *pAdapter = giAdapter; return true; }
// Get an adapter name bool spoutDirectX::GetAdapterName(int index, char *adaptername, int maxchars) { IDXGIFactory1* _dxgi_factory1; IDXGIAdapter* adapter1_ptr = nullptr; UINT32 i; if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) return false; for ( i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { if((int)i == index) { DXGI_ADAPTER_DESC desc; adapter1_ptr->GetDesc( &desc ); adapter1_ptr->Release(); size_t charsConverted = 0; wcstombs_s(&charsConverted, adaptername, maxchars, desc.Description, maxchars-1); // Is the adapter compatible ? // TODO : test for Intel graphics version ? // 11.08.15 - removed for use with Intel HD4400/5000 graphics // if(strstr(adaptername, "Intel")) { // printf("Intel graphics not supported\n"); // return false; // } _dxgi_factory1->Release(); return true; } } _dxgi_factory1->Release(); return false; }
bool spoutDirectX::GetAdapterInfo(char *adapter, char *display, int maxchars) { IDXGIFactory1* _dxgi_factory1; IDXGIAdapter* adapter1_ptr = nullptr; UINT32 i; size_t charsConverted = 0; // Enum Adapters first : multiple video cards if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) return false; for ( i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { DXGI_ADAPTER_DESC desc; adapter1_ptr->GetDesc( &desc ); // Return the current adapter - max of 2 assumed wcstombs_s(&charsConverted, adapter, maxchars, desc.Description, maxchars-1); IDXGIOutput* p_output = nullptr; for ( UINT32 j = 0; adapter1_ptr->EnumOutputs( j, &p_output ) != DXGI_ERROR_NOT_FOUND; j++ ) { DXGI_OUTPUT_DESC desc_out; p_output->GetDesc( &desc_out ); if(desc_out.AttachedToDesktop) wcstombs_s(&charsConverted, display, maxchars, desc.Description, maxchars-1); if( p_output ) p_output->Release(); } } _dxgi_factory1->Release(); return true; }
// Get an adapter name bool spoutDirectX::GetAdapterName(int index, char *adaptername, int maxchars) { IDXGIFactory1* _dxgi_factory1; IDXGIAdapter* adapter1_ptr = nullptr; UINT32 i; if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) return false; for ( i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { if((int)i == index) { DXGI_ADAPTER_DESC desc; adapter1_ptr->GetDesc( &desc ); adapter1_ptr->Release(); size_t charsConverted = 0; wcstombs_s(&charsConverted, adaptername, maxchars, desc.Description, maxchars-1); // Is the adapter compatible ? TODO _dxgi_factory1->Release(); return true; } } _dxgi_factory1->Release(); return false; }
CD3DRenderer::CD3DRenderer(HWND& window) { m_hWnd = window; if(FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&m_pdxgiFactory))) g_pDebug->printError("Failed to create DXGI Factory."); IDXGIAdapter1 * pAdapter; for (UINT i = 0; m_pdxgiFactory->EnumAdapters1(i, &pAdapter) != DXGI_ERROR_NOT_FOUND; ++i) m_vAdapters.push_back(pAdapter); IDXGIOutput *pOutput; m_vAdapters[m_uiCurrentAdapter]->EnumOutputs(0, &pOutput); UINT modeCount; pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &modeCount, nullptr); DXGI_MODE_DESC *descArr = new DXGI_MODE_DESC[modeCount]; pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &modeCount, descArr); for (UINT i = 0; i < modeCount; i++) { if (descArr[i].RefreshRate.Numerator / descArr[i].RefreshRate.Denominator <= 60) m_vAdapterModes.push_back(descArr[i]); } pOutput->Release(); delete[] descArr; }
BOOL CALLBACK create_device(PINIT_ONCE ignored, void *ignored2, void **ignored3) { debug_log("creating device"); HRESULT hr; hr = CreateDXGIFactory1(__uuidof(IDXGIFactory2), (void **)&dxgi_factory); assert(hr == S_OK); hr = dxgi_factory->EnumAdapters1(0, &dxgi_adapter); assert(hr == S_OK); hr = dxgi_adapter->EnumOutputs(0, &dxgi_output); assert(hr == S_OK); hr = dxgi_output->QueryInterface(__uuidof(IDXGIOutput1), (void **)&dxgi_output1); assert(hr == S_OK); const D3D_FEATURE_LEVEL levels[] = { D3D_FEATURE_LEVEL_11_0 }; D3D_FEATURE_LEVEL out_level; UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT; #ifndef NDEBUG flags |= D3D11_CREATE_DEVICE_DEBUG; #endif hr = D3D11CreateDevice(dxgi_adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, flags, levels, 1, D3D11_SDK_VERSION, &device, &out_level, &context); assert(hr == S_OK); hr = dxgi_output1->DuplicateOutput(device, &dxgi_output_duplication); assert(hr == S_OK); InitializeCriticalSection(&directx_critical_section); return TRUE; }
void Direct3DManager::InitializeDeviceResources() { #if defined(_DEBUG) // If the project is in a debug build, enable debugging via SDK Layers. { ID3D12Debug *debugController; if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) { debugController->EnableDebugLayer(); } debugController->Release(); debugController = NULL; } #endif Direct3DUtils::ThrowIfHRESULTFailed(CreateDXGIFactory1(IID_PPV_ARGS(&mDXGIFactory))); // Create the Direct3D 12 API device object Direct3DUtils::ThrowIfHRESULTFailed(D3D12CreateDevice( nullptr, // Specify nullptr to use the default adapter. D3D_FEATURE_LEVEL_11_0, // Minimum feature level this app can support. IID_PPV_ARGS(&mDevice) // Returns the Direct3D device created. )); mContextManager = new Direct3DContextManager(mDevice); }
static HRESULT find_output() { CComPtr<IDXGIFactory1> pFactory; HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)(&pFactory)); for (UINT i = 0; ; i++) { CComPtr<IDXGIAdapter1> pAdapter; if (S_OK != (hr = pFactory->EnumAdapters1(i, &pAdapter))) { break; } aslog::info(L"Found adapter %d", i); for (UINT j = 0; ; j++) { CComPtr<IDXGIOutput> pOutput; if (S_OK != (hr = pAdapter->EnumOutputs(j, &pOutput))) { break; } aslog::info(L"Found output %d-%d", i, j); DXGI_OUTPUT_DESC desc; pOutput->GetDesc(&desc); aslog::info(L"Output %d-%d name: %s", i, j, desc.DeviceName); aslog::info(L"Output %d-%d attached to desktop: %s", i, j, desc.AttachedToDesktop ? L"true" : L"false"); g_pAdapter = pAdapter; g_pOutput = pOutput; hr = D3D11CreateDevice(pAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, D3D11_CREATE_DEVICE_DEBUG, NULL, 0, D3D11_SDK_VERSION, &g_pDevice, NULL, &g_pContext); return hr; } } return hr; }
void GetDisplayDevices(DeviceOutputs &deviceList) { HRESULT err; deviceList.ClearData(); #ifdef USE_DXGI1_2 REFIID iidVal = OSGetVersion() >= 8 ? __uuidof(IDXGIFactory2) : __uuidof(IDXGIFactory1); #else REFIIF iidVal = __uuidof(IDXGIFactory1); #endif IDXGIFactory1 *factory; if(SUCCEEDED(err = CreateDXGIFactory1(iidVal, (void**)&factory))) { UINT i=0; IDXGIAdapter1 *giAdapter; while(factory->EnumAdapters1(i++, &giAdapter) == S_OK) { Log(TEXT("------------------------------------------")); DXGI_ADAPTER_DESC adapterDesc; if(SUCCEEDED(err = giAdapter->GetDesc(&adapterDesc))) { if (adapterDesc.DedicatedVideoMemory != 0) { DeviceOutputData &deviceData = *deviceList.devices.CreateNew(); deviceData.strDevice = adapterDesc.Description; UINT j=0; IDXGIOutput *giOutput; while(giAdapter->EnumOutputs(j++, &giOutput) == S_OK) { DXGI_OUTPUT_DESC outputDesc; if(SUCCEEDED(giOutput->GetDesc(&outputDesc))) { if(outputDesc.AttachedToDesktop) { deviceData.monitorNameList << outputDesc.DeviceName; MonitorInfo &monitorInfo = *deviceData.monitors.CreateNew(); monitorInfo.hMonitor = outputDesc.Monitor; mcpy(&monitorInfo.rect, &outputDesc.DesktopCoordinates, sizeof(RECT)); } } giOutput->Release(); } } } else AppWarning(TEXT("Could not query adapter %u"), i); giAdapter->Release(); } factory->Release(); } }
std::unique_ptr< WindowsAdapter > CreateWindowsAdapter( const int id ) noexcept { ComPtr< IDXGIFactory1 > factory; auto hresult = CreateDXGIFactory1( __uuidof( IDXGIFactory1 ), reinterpret_cast< void** >( &factory ) ); if ( FAILED( hresult ) ) { return nullptr; } return CreateAdapter( factory, id ); }
HRESULT WINAPI HookDXGIFactory(REFIID riid, void **ppFactory) { // We need shared texture support for OpenVR, so force DXGI 1.0 games to use DXGI 1.1 IDXGIFactory1* pDXGIFactory; HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&pDXGIFactory); if (FAILED(hr)) return hr; return pDXGIFactory->QueryInterface(riid, ppFactory); }
// LJ DEBUG bool spoutDirectX::FindNVIDIA(int &nAdapter) { IDXGIFactory1* _dxgi_factory1; IDXGIAdapter* adapter1_ptr = nullptr; DXGI_ADAPTER_DESC desc; // DXGI_OUTPUT_DESC desc_out; UINT32 i; bool bFound = false; if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) return false; for ( i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { adapter1_ptr->GetDesc( &desc ); printf( "Adapter(%d) : %S\n", i, desc.Description ); /* IDXGIOutput* p_output = nullptr; if(adapter1_ptr->EnumOutputs(0, &p_output ) == DXGI_ERROR_NOT_FOUND) { printf(" No outputs\n"); continue; } for ( UINT32 j = 0; adapter1_ptr->EnumOutputs( j, &p_output ) != DXGI_ERROR_NOT_FOUND; j++ ) { p_output->GetDesc( &desc_out ); // printf( " Output : %d\n", j ); // printf( " Name %S\n", desc_out.DeviceName ); // printf( " Attached to desktop : (%d) %s\n", desc_out.AttachedToDesktop, desc_out.AttachedToDesktop ? "yes" : "no" ); // printf( " Rotation : %d\n", desc_out.Rotation ); // printf( " Left : %d\n", desc_out.DesktopCoordinates.left ); // printf( " Top : %d\n", desc_out.DesktopCoordinates.top ); // printf( " Right : %d\n", desc_out.DesktopCoordinates.right ); // printf( " Bottom : %d\n", desc_out.DesktopCoordinates.bottom ); if( p_output ) p_output->Release(); } */ if(wcsstr(desc.Description, L"NVIDIA")) { // printf("Found NVIDIA adapter %d (%S)\n", i, desc.Description); bFound = true; break; } } _dxgi_factory1->Release(); if(bFound) { printf("Found NVIDIA adapter %d (%S)\n", i, desc.Description); nAdapter = i; return true; } return false; }
// Get the number of graphics adapters in the system int spoutDirectX::GetNumAdapters() { IDXGIFactory1* _dxgi_factory1; IDXGIAdapter* adapter1_ptr = nullptr; UINT32 i; // printf("spoutDirectX::GetNumAdapters\n"); // Enum Adapters first : multiple video cards if ( FAILED( CreateDXGIFactory1( __uuidof(IDXGIFactory1), (void**)&_dxgi_factory1 ) ) ) return 0; for ( i = 0; _dxgi_factory1->EnumAdapters( i, &adapter1_ptr ) != DXGI_ERROR_NOT_FOUND; i++ ) { // DXGI_ADAPTER_DESC desc; // adapter1_ptr->GetDesc( &desc ); // printf( "Adapter : %S\n", desc.Description ); // adapter1_ptr->Release(); // printf( "bdd_spout : D3D11 Adapter %d found\n", i ); DXGI_ADAPTER_DESC desc; adapter1_ptr->GetDesc( &desc ); printf( "Adapter(%d) : %S\n", i, desc.Description ); printf( " Vendor Id : %d\n", desc.VendorId ); // printf( " Dedicated System Memory : %.0f MiB\n", (float)desc.DedicatedSystemMemory / (1024.f * 1024.f) ); // printf( " Dedicated Video Memory : %.0f MiB\n", (float)desc.DedicatedVideoMemory / (1024.f * 1024.f) ); // printf( " Shared System Memory : %.0f MiB\n", (float)desc.SharedSystemMemory / (1024.f * 1024.f) ); IDXGIOutput* p_output = nullptr; if(adapter1_ptr->EnumOutputs(0, &p_output ) == DXGI_ERROR_NOT_FOUND) { printf(" No outputs\n"); } for ( UINT32 j = 0; adapter1_ptr->EnumOutputs( j, &p_output ) != DXGI_ERROR_NOT_FOUND; j++ ) { DXGI_OUTPUT_DESC desc_out; p_output->GetDesc( &desc_out ); printf( " Output : %d\n", j ); printf( " Name %S\n", desc_out.DeviceName ); printf( " Attached to desktop : (%d) %s\n", desc_out.AttachedToDesktop, desc_out.AttachedToDesktop ? "yes" : "no" ); printf( " Rotation : %d\n", desc_out.Rotation ); printf( " Left : %d\n", desc_out.DesktopCoordinates.left ); printf( " Top : %d\n", desc_out.DesktopCoordinates.top ); printf( " Right : %d\n", desc_out.DesktopCoordinates.right ); printf( " Bottom : %d\n", desc_out.DesktopCoordinates.bottom ); if( p_output ) p_output->Release(); } } _dxgi_factory1->Release(); return (int)i; }
/// Overriden in derived class to initialize the graphics required for a render loop. The render loop acts as a message pump to the user clients. /// \return True if success, false if failure bool DX12Player::InitializeGraphics() { ID3D12Device* graphicsDevice = nullptr; UINT frameCount = 2; // Initialize all pipeline components necessary to render a frame. /// Invoking these calls will allow the DXGI/DX12Server plugins to be injected into our player application. // @TODO: In the future, the following commands will invoked by loaded a capture file, // initializing, and executing all captured calls. Spinning on the target frame will beat // the DX12Server's message loop, allowing communicate with GPUPerfServer. IDXGIFactory4* factory = nullptr; ThrowIfFailed(CreateDXGIFactory1(IID_PPV_ARGS(&factory))); ThrowIfFailed(D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&graphicsDevice))); // Describe and create the command queue. D3D12_COMMAND_QUEUE_DESC queueDesc = {}; queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; ID3D12CommandQueue* commandQueue = nullptr; ThrowIfFailed(graphicsDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue))); // Describe and create the swap chain. DXGI_SWAP_CHAIN_DESC swapChainDesc = {}; swapChainDesc.BufferCount = frameCount; swapChainDesc.BufferDesc.Width = m_pPlayerWindow->GetWindowWidth(); swapChainDesc.BufferDesc.Height = m_pPlayerWindow->GetWindowHeight(); swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; // The window handle must be set before being used here. swapChainDesc.OutputWindow = m_pPlayerWindow->GetWindowHandle(); swapChainDesc.SampleDesc.Count = 1; swapChainDesc.Windowed = TRUE; HRESULT res = factory->CreateSwapChain(commandQueue, &swapChainDesc, (IDXGISwapChain**)&m_swapchain); ThrowIfFailed(res); if (res != S_OK) { return false; } else { return true; } }
HRESULT AppTest::CreateDeviceAndSwapChain(IDXGIAdapter * adapter, D3D_DRIVER_TYPE driverType, D3D_FEATURE_LEVEL minFeatureLevel, CONST DXGI_SWAP_CHAIN_DESC * swapChainDesc, REFIID riidSwapChain, void ** ppSwapChain, REFIID riidDevice, void ** ppDevice, REFIID riidQueue, void ** ppQueue) { ComPtr<ID3D12Device> device; ComPtr<IDXGIFactory> dxgiFactory; ComPtr<IDXGISwapChain> swapChain; ComPtr<ID3D12CommandQueue> queue; HRESULT hr = D3D12CreateDevice(adapter, minFeatureLevel, IID_PPV_ARGS(device.GetAddressOf())); if (FAILED(hr)) return hr; D3D12_COMMAND_QUEUE_DESC queueDesc; ZeroMemory(&queueDesc, sizeof(queueDesc)); queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; hr = device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(queue.GetAddressOf())); hr = CreateDXGIFactory1(IID_PPV_ARGS(dxgiFactory.GetAddressOf())); if (FAILED(hr)) return hr; DXGI_SWAP_CHAIN_DESC localSwapChainDesc = *swapChainDesc; hr = dxgiFactory->CreateSwapChain(queue.Get(), &localSwapChainDesc, &swapChain); if (FAILED(hr)) return hr; hr = device.Get()->QueryInterface(riidDevice, ppDevice); if (FAILED(hr)) return hr; hr = queue.Get()->QueryInterface(riidQueue, ppQueue); if (FAILED(hr)) return hr; hr = swapChain.Get()->QueryInterface(riidSwapChain, ppSwapChain); if (FAILED(hr)) { reinterpret_cast<IUnknown*>(*ppDevice)->Release(); return hr; } return S_OK; }
void LogVideoCardStats() { HRESULT err; #ifdef USE_DXGI1_2 REFIID iidVal = OSGetVersion() >= 8 ? __uuidof(IDXGIFactory2) : __uuidof(IDXGIFactory1); #else REFIIF iidVal = __uuidof(IDXGIFactory1); #endif IDXGIFactory1 *factory; if(SUCCEEDED(err = CreateDXGIFactory1(iidVal, (void**)&factory))) { UINT i=0; IDXGIAdapter1 *giAdapter; while(factory->EnumAdapters1(i++, &giAdapter) == S_OK) { DXGI_ADAPTER_DESC adapterDesc; if(SUCCEEDED(err = giAdapter->GetDesc(&adapterDesc))) { if (!(adapterDesc.VendorId == 0x1414 && adapterDesc.DeviceId == 0x8c)) { // Ignore Microsoft Basic Render Driver Log(TEXT("------------------------------------------")); Log(TEXT("Adapter %u"), i); Log(TEXT(" Video Adapter: %s"), adapterDesc.Description); Log(TEXT(" Video Adapter Dedicated Video Memory: %u"), adapterDesc.DedicatedVideoMemory); Log(TEXT(" Video Adapter Shared System Memory: %u"), adapterDesc.SharedSystemMemory); UINT j = 0; IDXGIOutput *output; while(SUCCEEDED(giAdapter->EnumOutputs(j++, &output))) { DXGI_OUTPUT_DESC desc; if(SUCCEEDED(output->GetDesc(&desc))) Log(TEXT(" Video Adapter Output %u: pos={%d, %d}, size={%d, %d}, attached=%s"), j, desc.DesktopCoordinates.left, desc.DesktopCoordinates.top, desc.DesktopCoordinates.right-desc.DesktopCoordinates.left, desc.DesktopCoordinates.bottom-desc.DesktopCoordinates.top, desc.AttachedToDesktop ? L"true" : L"false"); output->Release(); } } } else AppWarning(TEXT("Could not query adapter %u"), i); giAdapter->Release(); } factory->Release(); } }
void gs_device::InitFactory(uint32_t adapterIdx, IDXGIAdapter1 **padapter) { HRESULT hr; IID factoryIID = (GetWinVer() >= 0x602) ? dxgiFactory2 : __uuidof(IDXGIFactory1); hr = CreateDXGIFactory1(factoryIID, (void**)factory.Assign()); if (FAILED(hr)) throw UnsupportedHWError("Failed to create DXGIFactory", hr); hr = factory->EnumAdapters1(adapterIdx, padapter); if (FAILED(hr)) throw UnsupportedHWError("Failed to enumerate DXGIAdapter", hr); }
bool Device::apiInit(const Desc& desc) { DeviceApiData* pData = new DeviceApiData; mpApiData = pData; if (desc.enableDebugLayer) { ID3D12DebugPtr pDebug; if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&pDebug)))) { pDebug->EnableDebugLayer(); } } // Create the DXGI factory d3d_call(CreateDXGIFactory1(IID_PPV_ARGS(&mpApiData->pDxgiFactory))); mApiHandle = createDevice(mpApiData->pDxgiFactory, getD3DFeatureLevel(desc.apiMajorVersion, desc.apiMinorVersion), desc.createDeviceFunc, mRgb32FloatSupported); if (mApiHandle == nullptr) { return false; } for (uint32_t i = 0; i < kQueueTypeCount; i++) { for (uint32_t j = 0; j < desc.cmdQueues[i]; j++) { // Create the command queue D3D12_COMMAND_QUEUE_DESC cqDesc = {}; cqDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; cqDesc.Type = getApiCommandQueueType((LowLevelContextData::CommandQueueType)i); ID3D12CommandQueuePtr pQueue; if (FAILED(mApiHandle->CreateCommandQueue(&cqDesc, IID_PPV_ARGS(&pQueue)))) { logError("Failed to create command queue"); return nullptr; } mCmdQueues[i].push_back(pQueue); } } uint64_t freq; d3d_call(getCommandQueueHandle(LowLevelContextData::CommandQueueType::Direct, 0)->GetTimestampFrequency(&freq)); mGpuTimestampFrequency = 1000.0 / (double)freq; return true; }
IDXGIAdapter1 *D3D11Renderer::GetPrimaryAdaptor() { IDXGIFactory1 *factory = 0; if (CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&factory) == S_OK) { IDXGIAdapter1 *adapter = 0; factory->EnumAdapters1(0, &adapter); memory::SafeRelease(&factory); memory::SafeRelease(&adapter); return adapter; } memory::SafeRelease(&factory); return 0; }
void D3D11Renderer::EnumerateDisplayModes() { IDXGIFactory1 *factory = 0; if (CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&factory) == S_OK) { IDXGIAdapter1 *adapter = 0; for (UINT i = 0; factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++) { DXGI_ADAPTER_DESC1 ad; adapter->GetDesc1(&ad); char description[128]; size_t n; wcstombs_s(&n, description, ad.Description, 128); ATOM_LOG("-------------------------------------------------------------------------------\n"); ATOM_LOG("[info]: adapter[%d]: %s\n", i, description); ATOM_LOG("[info]: - revision: %d\n", i, ad.Revision); ATOM_LOG("[info]: - video memory: %d\n", i, ad.DedicatedVideoMemory / 1024 / 1024); ATOM_LOG("[info]: - system memory: %d\n", i, ad.DedicatedSystemMemory / 1024 / 1024); ATOM_LOG("[info]: - shared system memory: %d\n", i, ad.SharedSystemMemory / 1024 / 1024); IDXGIOutput *output = 0; for (UINT j = 0; adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND; j++) { UINT modesCount; DXGI_FORMAT format = g_settings.format; output->GetDisplayModeList(format, 0, &modesCount, 0); DXGI_MODE_DESC *modeDescs = new DXGI_MODE_DESC[modesCount]; output->GetDisplayModeList(format, 0, &modesCount, modeDescs); ATOM_LOG("[info]: - output %d display modes(%d)\n", j, modesCount); for (UINT k = 0; k < modesCount; k++) { ATOM_LOG("[info]: -- mode[%d]: %d * %d", k, modeDescs[k].Width, modeDescs[k].Height); ATOM_LOG(", refresh rate: %d/%d\n", modeDescs[i].RefreshRate.Numerator, modeDescs[i].RefreshRate.Denominator); } delete[] modeDescs; memory::SafeRelease(&output); } memory::SafeRelease(&adapter); } } memory::SafeRelease(&factory); }
bool SystemCheck::CheckVRAMSize() { HRESULT hr; D3D_FEATURE_LEVEL FeatureLevel; CComPtr<IDXGIFactory1> DXGIFactory; hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&DXGIFactory); if(SUCCEEDED(hr)) { CComPtr<IDXGIAdapter1> Adapter; hr = DXGIFactory->EnumAdapters1(0, &Adapter); if(SUCCEEDED(hr)) { CComPtr<ID3D11Device> Device; CComPtr<ID3D11DeviceContext> DeviceContext; hr = D3D11CreateDevice(Adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0, D3D11_SDK_VERSION, &Device, &FeatureLevel, &DeviceContext); if(SUCCEEDED(hr)) { DXGI_ADAPTER_DESC adapterDesc; Adapter->GetDesc(&adapterDesc); std::wstring Description = adapterDesc.Description; INT64 VideoRam = adapterDesc.DedicatedVideoMemory; INT64 SystemRam = adapterDesc.DedicatedSystemMemory; INT64 SharedRam = adapterDesc.SharedSystemMemory; std::wcout << "***************** GRAPHICS ADAPTER DETAILS ***********************" << endl;; std::wcout << "Adapter Description: " << Description << endl; std::wcout << "Dedicated Video RAM: " << VideoRam << endl; std::wcout << "Dedicated System RAM: " << SystemRam << endl; std::wcout << "Shared System RAM: " << SharedRam << endl; std::wcout << "PCI ID: " << Description << endl; std::wcout << "Feature Level: " << FeatureLevel << endl; } } } return true; }
/** * コンストラクタ * * @param hwnd ウィンドウハンドル * @param w バックバッファの幅 * @param h バックバッファの高さ * @param full_screen フルスクリーンフラグ * @param adapter_format 未使用 * @param depth_stencil_format 未使用 * @param multi_sample_count マルチサンプリングのサンプル数 * @param multi_sample_quality マルチサンプリングのクオリティ */ Direct3D11::Direct3D11( HWND hwnd, int w, int h, bool full_screen, const char* /* adapter_format */, const char* /* depth_stencil_format */, int multi_sample_count, int multi_sample_quality ) : device_( 0 ) , immediate_context_( 0 ) , swap_chain_( 0 ) , back_buffer_texture_( 0 ) , back_buffer_view_( 0 ) , depth_stencil_texture_( 0 ) , depth_stencil_view_( 0 ) , device_10_( 0 ) , back_buffer_surface_( 0 ) , text_texture_( 0 ) , text_view_( 0 ) , text_texture_mutex_11_( 0 ) , text_texture_mutex_10_( 0 ) { common::log( "log/d3d11.log", "init", false ); IDXGIFactory1* dxgi_factory = 0; DIRECT_X_FAIL_CHECK( CreateDXGIFactory1( __uuidof( IDXGIFactory1 ), reinterpret_cast< void** >( & dxgi_factory ) ) ); log_all_adapter_desc( dxgi_factory ); DIRECT_X_FAIL_CHECK( dxgi_factory->EnumAdapters1( 0, & dxgi_adapter_ ) ); create_device(); log_feature_level(); create_swap_chain( dxgi_factory, hwnd, w, h, full_screen, multi_sample_count, multi_sample_quality ); DIRECT_X_RELEASE( dxgi_factory ); create_back_buffer_view(); create_back_buffer_surface(); create_depth_stencil_view(); setup_viewport(); sprite_ = new Sprite( this ); effect_ = new Effect( this ); }
std::vector<IDXGIAdapter*> EnumerateDXGIAdapters() { IDXGIAdapter * adaptor; std::vector <IDXGIAdapter*> adaptors; IDXGIFactory1* factory = NULL; // Create a DXGIFactory object. if(FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1) ,(void**)&factory))) { return adaptors; } for (auto i = 0; factory->EnumAdapters(i, &adaptor) != DXGI_ERROR_NOT_FOUND; ++i) { adaptors.push_back(adaptor); } SafeRelease(&factory); return adaptors; }
DXGI_RATIONAL D3D11Renderer::GetDefaultRefreshRate() { DXGI_RATIONAL refreshRate = {59, 1}; IDXGIFactory1 *factory = 0; if (CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&factory) == S_OK) { IDXGIAdapter1 *adapter = 0; for (UINT i = 0; factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++) { DXGI_ADAPTER_DESC1 ad; IDXGIOutput *output = 0; adapter->GetDesc1(&ad); for (UINT j = 0; adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND; j++) { UINT modesCount; DXGI_FORMAT format = g_settings.format; output->GetDisplayModeList(format, 0, &modesCount, 0); DXGI_MODE_DESC *modeDescs = new DXGI_MODE_DESC[modesCount]; output->GetDisplayModeList(format, 0, &modesCount, modeDescs); for (UINT k = 0; k < modesCount; k++) { if (modeDescs[k].Width == (UINT)g_settings.width && modeDescs[k].Height == (UINT)g_settings.height) { refreshRate = modeDescs[i].RefreshRate; delete[] modeDescs; memory::SafeRelease(&output); memory::SafeRelease(&adapter); memory::SafeRelease(&factory); return refreshRate; } } delete[] modeDescs; memory::SafeRelease(&output); } memory::SafeRelease(&adapter); } } memory::SafeRelease(&factory); return refreshRate; }
std::unique_ptr< WindowsAdapter > CreateWindowsAdapter( const WindowsAdapterCapabilities& capabilities ) noexcept { ComPtr< IDXGIFactory1 > factory; auto hresult = CreateDXGIFactory1( __uuidof( IDXGIFactory1 ), reinterpret_cast< void** >( &factory ) ); if ( FAILED( hresult ) ) { return nullptr; } int id = 0; auto adapter = CreateAdapter( factory, id ); while ( adapter != nullptr ) { // check capabilities if ( adapter->CheckCapabilities( capabilities ) ) { return adapter; } // next adapter id += 1; adapter = CreateAdapter( factory, id ); } return nullptr; }
bool RenderCore::EnumerateDisplayAdapters(std::vector<IDXGIAdapter1 *> *dxgiAdapters) { IDXGIAdapter1 *pAdapter; IDXGIFactory1 *pFactory = nullptr; HRESULT hr; hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory); if (FAILED(hr)) { return false; } for (UINT i = 0; pFactory->EnumAdapters1(i, &pAdapter) != DXGI_ERROR_NOT_FOUND; ++i) { dxgiAdapters->push_back(pAdapter); //m_VideoAdapterList.push_back(pAdapter); } if (pFactory) { pFactory->Release(); } return true; };