//======================================================================== // Initialize hardware for rendering. Member of AbstractRender //======================================================================== HRESULT DX10Render::initDevice() { UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HRESULT hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &this->device); if (FAILED(hr)) return hr; DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = this->resolution.width; sd.BufferDesc.Height = this->resolution.height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = this->hWindow; sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = 4; sd.Windowed = !this->fullscreen; IDXGIFactory *factory = getDeviceFactory(device); if (factory == NULL) return E_FAIL; hr = factory->CreateSwapChain(device, &sd, &swapChain); if (FAILED(hr)) return hr; factory->Release(); return S_OK; }
/* * Class: org_lwjgl_d3d11_impl_DXGIFactoryImpl * Method: nCreateSwapChain * Signature: (JJJJ)J */ extern "C" JNIEXPORT jlong JNICALL Java_org_lwjgl_d3d11_impl_DXGIFactoryImpl_nCreateSwapChain (JNIEnv * env, jclass clazz, jlong thisPtr, jlong devicePtr, jlong swapChainDescPtr, jlong swapChainOutPtr) { IDXGIFactory* factory = (IDXGIFactory*)(intptr_t)thisPtr; IUnknown* device = (IUnknown*)(intptr_t)devicePtr; DXGI_SWAP_CHAIN_DESC* swapChainDesc = (DXGI_SWAP_CHAIN_DESC*)(intptr_t)swapChainDescPtr; IDXGISwapChain** swapChain = (IDXGISwapChain**)(intptr_t)swapChainOutPtr; return (jlong)factory->CreateSwapChain(device, swapChainDesc, swapChain); }
void D3D11RenderWindow::_createSwapChain() { // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = mWidth; sd.BufferDesc.Height = mHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Use 4X MSAA? if (mEnable4xMsaa) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m4xMsaaQuality - 1; } // No MSAA else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 2; sd.OutputWindow = mhMainWnd; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // To correctly create the swap chain, we must use the IDXGIFactory that was // used to create the device. If we tried to use a different IDXGIFactory instance // (by calling CreateDXGIFactory), we get an error: "IDXGIFactory::CreateSwapChain: // This function is being called with a device from a different IDXGIFactory." IDXGIDevice* dxgiDevice = 0; HR(md3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice)); IDXGIAdapter* dxgiAdapter = 0; HR(dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); IDXGIFactory* dxgiFactory = 0; HR(dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory)); HR(dxgiFactory->CreateSwapChain(md3dDevice, &sd, &mSwapChain)); ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); // The remaining steps that need to be carried out for d3d creation // also need to be executed every time the window is resized. So // just call the OnResize method here to avoid code duplication. _updateSwapChain(); }
void D3DContext::InitD3D(HWND hWnd) { m_MSAAEnabled = true; HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, m_DebugLayerEnabled ? D3D11_CREATE_DEVICE_DEBUG : D3D11_CREATE_DEVICE_SINGLETHREADED, NULL, NULL, D3D11_SDK_VERSION, &dev, &m_D3DFeatureLevel, &devcon); dev->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m_MSAAQuality); // assert(m_MSAAQuality > 0); DXGI_SWAP_CHAIN_DESC scd; ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC)); scd.BufferDesc.Width = m_Properties.width; scd.BufferDesc.Height = m_Properties.height; scd.BufferDesc.RefreshRate.Numerator = 60; scd.BufferDesc.RefreshRate.Denominator = 1; scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; scd.SampleDesc.Count = m_MSAAEnabled ? 4 : 1; scd.SampleDesc.Quality = m_MSAAEnabled ? (m_MSAAQuality - 1) : 0; scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scd.BufferCount = 3; scd.OutputWindow = hWnd; scd.Windowed = !m_Properties.fullscreen; scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; IDXGIDevice* dxgiDevice = 0; IDXGIAdapter* dxgiAdapter = 0; IDXGIFactory* dxgiFactory = 0; dev->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); dxgiFactory->CreateSwapChain(dev, &scd, &swapchain); dxgiFactory->Release(); dxgiAdapter->Release(); dxgiDevice->Release(); if (m_DebugLayerEnabled) { dev->QueryInterface(__uuidof(ID3D11Debug), reinterpret_cast<void**>(&m_DebugLayer)); m_DebugLayer->ReportLiveDeviceObjects(D3D11_RLDO_SUMMARY); ID3D11InfoQueue* infoQueue; dev->QueryInterface(__uuidof(ID3D11InfoQueue), reinterpret_cast<void**>(&infoQueue)); D3D11_MESSAGE_ID hide[] = { D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET }; D3D11_INFO_QUEUE_FILTER filter; memset(&filter, 0, sizeof(filter)); filter.DenyList.NumIDs = 1; filter.DenyList.pIDList = hide; infoQueue->AddStorageFilterEntries(&filter); } Resize(); }
bool TRenderDevice::CreateSwapChain(){ IDXGIDevice* device; if (FAILED(Device->QueryInterface(__uuidof(IDXGIDevice), (void**) &device))){ MessageBox(0,L"获取设备接口失败",0,0); return false; } IDXGIAdapter* adapter; if (FAILED(device->GetParent(__uuidof(IDXGIAdapter), (void**) &adapter))){ MessageBox(0,L"获取适配器接口失败",0,0); return false; } IDXGIFactory* factory; if (FAILED(adapter->GetParent(__uuidof(IDXGIFactory), (void**) &factory))){ MessageBox(0,L"获取Factory接口失败",0,0); return false; } DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = RenderSize->GetRenderWidth(); sd.BufferDesc.Height = RenderSize->GetRenderHeight(); sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if (MsaaQuality>0){ sd.SampleDesc.Count = MsaaQuality; sd.SampleDesc.Quality = MsaaQuality - 1; }else{ sd.SampleDesc.Count=1; sd.SampleDesc.Quality=0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = RenderWindow->GetHWnd(); sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; if (FAILED(factory->CreateSwapChain(Device, &sd, &SwapChain))){ MessageBox(0,L"创建SwapChain失败",0,0); return false; } device->Release(); adapter->Release(); factory->Release(); return true; }
EGLint SwapChain11Api::createSwapChain( int backbufferWidth, int backbufferHeight, IDXGISwapChain **outSwapChain) { // We cannot create a swap chain for an HWND that is owned by a // different process DWORD currentProcessId = GetCurrentProcessId(); DWORD wndProcessId; GetWindowThreadProcessId((HWND)mWindow, &wndProcessId); if (currentProcessId != wndProcessId) { ERR("Could not create swap chain, window owned by different process"); return EGL_BAD_NATIVE_WINDOW; } ID3D11Device *device = getRenderer()->getDevice(); IDXGIFactory *factory = getRenderer()->getDxgiFactory(); DXGI_FORMAT format = gl_d3d11::ConvertRenderbufferFormat(mBackBufferFormat); DXGI_SWAP_CHAIN_DESC swapChainDesc = {0}; swapChainDesc.BufferCount = 2; swapChainDesc.BufferDesc.Format = format; swapChainDesc.BufferDesc.Width = backbufferWidth; swapChainDesc.BufferDesc.Height = backbufferHeight; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.Flags = 0; swapChainDesc.OutputWindow = mWindow; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.Windowed = TRUE; IDXGISwapChain *swapChain; HRESULT result = factory->CreateSwapChain(device, &swapChainDesc, &swapChain); if (SUCCEEDED(result)) { *outSwapChain = swapChain; d3d11::ResourceTracker::Track(swapChain); return EGL_SUCCESS; } else { if (d3d11::isDeviceLostError(result)) return EGL_CONTEXT_LOST; else return EGL_BAD_ALLOC; } }
//************************************************************************************************* // Create the swap chain for the device //************************************************************************************************* SBOOL RenderContext::createSwapChain(HWND clientWindow, SUINT clientWidth, SUINT clientHeight) { // Fill out DXGI swap chain description DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = clientWidth; sd.BufferDesc.Height = clientHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Use 4x Msaa if(_4xMsaaEnabled) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = _4xMsaaQuality - 1; } // No Msaa else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = clientWindow; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // Generate an IDXGI factory to properly initialize the swap chain IDXGIDevice* dxgiDevice = 0; HR(_d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice)); IDXGIAdapter* dxgiAdapter = 0; HR(dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); IDXGIFactory* dxgiFactory = 0; HR(dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory)); HR(dxgiFactory->CreateSwapChain(_d3dDevice, &sd, &_swapChain)); ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); return true; }
std::shared_ptr<SwapChain> Device::createSwapChain(const Window& window) { std::shared_ptr<SwapChain> swapChain; IDXGIDevice* dxgiDevice = nullptr; if (SUCCEEDED(m_device->QueryInterface<IDXGIDevice>(&dxgiDevice))) { IDXGIAdapter* adapter = nullptr; if (SUCCEEDED(dxgiDevice->GetAdapter(&adapter))) { IDXGIFactory* dxgiFactory = nullptr; if (SUCCEEDED(adapter->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&dxgiFactory)))) { DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = window.getWidth(); sd.BufferDesc.Height = window.getHeight(); sd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 0; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = window.getPlatformData()->getHandle(); sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; IDXGISwapChain* nativeSwapChain = nullptr; if (SUCCEEDED(dxgiFactory->CreateSwapChain(m_device, &sd, &nativeSwapChain))) { ID3D11Texture2D* backBufferTexture = nullptr; if (SUCCEEDED(nativeSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBufferTexture)))) { auto texture = std::make_shared<Texture2d>(backBufferTexture); auto backBufferRenderCommandEncoder = createRenderCommandEncoder(1, &texture, nullptr, false); swapChain = std::make_shared<SwapChain>(nativeSwapChain, backBufferRenderCommandEncoder); } dxgiFactory->Release(); } adapter->Release(); } } dxgiDevice->Release(); } return swapChain; }
HRESULT STDMETHODCALLTYPE CDXGIFactoryDWM::CreateSwapChain(IUnknown *pDevice, DXGI_SWAP_CHAIN_DESC *pDesc, IDXGIOutput *pOutput, IDXGISwapChainDWM **ppSwapChain) { IDXGISwapChain *pSwapChain = NULL; if (retrace::forceWindowed) { pDesc->Windowed = TRUE; } HRESULT hr = m_pFactory->CreateSwapChain(pDevice, pDesc, &pSwapChain); if (SUCCEEDED(hr)) { if (!retrace::forceWindowed) { pSwapChain->SetFullscreenState(TRUE, pOutput); } *ppSwapChain = new CDXGISwapChainDWM(pSwapChain); } return hr; }
Error::E RenderSystem::CreateSwapChain(const Window &window) { assert(_device); _swapDesc = kDefaultSwapDesc; _swapDesc.SampleDesc.Count = 4; _swapDesc.SampleDesc.Quality = _msaaQualityLevel - 1; _swapDesc.OutputWindow = window.GetHandle(); _swapDesc.BufferDesc.Width = window.GetWidth(); _swapDesc.BufferDesc.Height = window.GetHeight(); IDXGIFactory *factory = FactoryFromDevice(_device); DEBUG_HR(factory->CreateSwapChain(_device, &_swapDesc, &_swapChain)); ReleaseCom(factory); return Error::OK; }
void D3DApplication::InitDirect3D() { // Create the device. UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HR(D3D10CreateDevice(0, m_DriverType, 0, createDeviceFlags, D3D10_SDK_VERSION, &m_pDevice)); IDXGIFactory* pFactory; HR(CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&pFactory))); // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC swapChainDescription; swapChainDescription.BufferDesc.Width = m_ClientWidth; swapChainDescription.BufferDesc.Height = m_ClientHeight; swapChainDescription.BufferDesc.RefreshRate.Numerator = 60; swapChainDescription.BufferDesc.RefreshRate.Denominator = 1; swapChainDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // No multisampling. swapChainDescription.SampleDesc.Count = 1; swapChainDescription.SampleDesc.Quality = 0; swapChainDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDescription.BufferCount = 1; swapChainDescription.OutputWindow = m_hMainWindow; swapChainDescription.Windowed = true; swapChainDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDescription.Flags = 0; HR(pFactory->CreateSwapChain(m_pDevice, &swapChainDescription, &m_pSwapChain)); HR(pFactory->MakeWindowAssociation(m_hMainWindow, DXGI_MWA_NO_WINDOW_CHANGES)); // The remaining steps that need to be carried out for d3d creation // also need to be executed every time the window is resized. So // just call the OnResize method here to avoid code duplication. OnResize(); }
bool Renderer::CreateSwapChain() { // Determine buffer size RECT rect; GetClientRect(hwnd,&rect); // Create swap chain DXGI_SWAP_CHAIN_DESC SwapChainDesc; SwapChainDesc.BufferCount = 1; SwapChainDesc.BufferDesc.Width = rect.right - rect.left; SwapChainDesc.BufferDesc.Height = rect.bottom - rect.top; SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; SwapChainDesc.BufferDesc.RefreshRate.Numerator = 60; SwapChainDesc.BufferDesc.RefreshRate.Denominator = 1; // 60/1 = 60 Hz SwapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; SwapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; SwapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; SwapChainDesc.OutputWindow = hwnd; SwapChainDesc.SampleDesc.Count = 1; SwapChainDesc.SampleDesc.Quality = 0; // no AA SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; SwapChainDesc.Windowed = true; // Obtain DXGI factory that was used to create the device // ??? IDXGIDevice* DXGIDevice; D3DDevice->QueryInterface(__uuidof(IDXGIDevice),(void**)&DXGIDevice); IDXGIAdapter* DXGIAdapter; DXGIDevice->GetParent(__uuidof(IDXGIAdapter),(void**)&DXGIAdapter); IDXGIFactory* DXGIFactory; DXGIAdapter->GetParent(__uuidof(IDXGIFactory),(void**)&DXGIFactory); // Use it if(DXGIFactory->CreateSwapChain(D3DDevice,&SwapChainDesc,&SwapChain) != S_OK) { MessageBox(hwnd,"Error creating swap chain","Error",MB_OK); return false; } // Release unused stuff DXGIDevice->Release(); DXGIAdapter->Release(); DXGIFactory->Release(); return true; }
boolean RendererD3D11::assembleUnit() { ProcessingUnitPtr windowUnit = ProcessingUnitPtr::null; window->getData( windowUnit ); if( !windowUnit.isNull() ) { WindowPtr wnd = staticCast<Window>( windowUnit ); RenderDeviceD3D11* rd = static_cast<RenderDeviceD3D11*>( owner ); IDXGIFactory* dxgiFactory = rd->getDXGIFactory(); DXGI_SWAP_CHAIN_DESC desc; desc.BufferCount = 1; desc.BufferDesc.Width = wnd->getWidth(); desc.BufferDesc.Height = wnd->getHeight(); desc.BufferDesc.Format = MapperD3D11::mapPixelFormat( Render::PF_RGBA8UN ); desc.BufferDesc.RefreshRate.Numerator = 60; desc.BufferDesc.RefreshRate.Denominator = 1; desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; desc.OutputWindow = (HWND)wnd->getHandle(); desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Windowed = !wnd->isFullscreen(); desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; IDXGISwapChain* sc = 0; HRESULT hr = dxgiFactory->CreateSwapChain( rd->getD3DDevice(), &desc, &sc ); if( SUCCEEDED( hr ) ) { swapchains.add( sc ); wnd->setSwapChain( sc ); return true; } } return false; }
//--------------------------------------------------------------------- void D3D10RenderWindow::createD3DResources(void) { if (mIsSwapChain && mDevice.isNull()) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Secondary window has not been given the device from the primary!", "D3D10RenderWindow::createD3DResources"); } //SAFE_RELEASE(mpRenderSurface); // Set up the presentation parameters // int pD3D = mDriver->getD3D(); // D3DDEVTYPE devType = D3DDEVTYPE_HAL; ZeroMemory( &md3dpp, sizeof(DXGI_SWAP_CHAIN_DESC) ); md3dpp.Windowed = !mIsFullScreen; md3dpp.SwapEffect = DXGI_SWAP_EFFECT_DISCARD ; // triple buffer if VSync is on md3dpp.BufferCount = mVSync ? 2 : 1; md3dpp.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; md3dpp.OutputWindow = mHWnd; md3dpp.BufferDesc.Width = mWidth; md3dpp.BufferDesc.Height = mHeight; md3dpp.BufferDesc.RefreshRate.Numerator=1; md3dpp.BufferDesc.RefreshRate.Denominator = 1; if (mIsFullScreen) { md3dpp.BufferDesc.Scaling = DXGI_MODE_SCALING_STRETCHED; md3dpp.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST; md3dpp.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH ; } md3dpp.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; D3D10RenderSystem* rsys = static_cast<D3D10RenderSystem*>(Root::getSingleton().getRenderSystem()); rsys->determineFSAASettings(mFSAA, mFSAAHint, md3dpp.BufferDesc.Format, &mFSAAType); if (mVSync) { // md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; } else { // NB not using vsync in windowed mode in D3D10 can cause jerking at low // frame rates no matter what buffering modes are used (odd - perhaps a // timer issue in D3D10 since GL doesn't suffer from this) // low is < 200fps in this context if (!mIsFullScreen) { LogManager::getSingleton().logMessage("D3D10 : WARNING - " "disabling VSync in windowed mode can cause timing issues at lower " "frame rates, turn VSync on if you observe this problem."); } // md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; } /* md3dpp.BufferDesc.Format= BackBufferFormat = D3DFMT_R5G6B5; if( mColourDepth > 16 ) md3dpp.BackBufferFormat = D3DFMT_X8R8G8B8; if (mColourDepth > 16 ) { // Try to create a 32-bit depth, 8-bit stencil if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(), devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24S8 ))) { // Bugger, no 8-bit hardware stencil, just try 32-bit zbuffer if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(), devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D32 ))) { // Jeez, what a naff card. Fall back on 16-bit depth buffering md3dpp.AutoDepthStencilFormat = D3DFMT_D16; } else md3dpp.AutoDepthStencilFormat = D3DFMT_D32; } else { // Woohoo! if( SUCCEEDED( pD3D->CheckDepthStencilMatch( mDriver->getAdapterNumber(), devType, md3dpp.BackBufferFormat, md3dpp.BackBufferFormat, D3DFMT_D24S8 ) ) ) { md3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; } else md3dpp.AutoDepthStencilFormat = D3DFMT_D24X8; } } else // 16-bit depth, software stencil md3dpp.AutoDepthStencilFormat = D3DFMT_D16; */ md3dpp.SampleDesc.Count = mFSAAType.Count; md3dpp.SampleDesc.Quality = mFSAAType.Quality; if (mIsSwapChain) { IDXGIFactory* mpDXGIFactory; HRESULT hr; hr = CreateDXGIFactory( IID_IDXGIFactory, (void**)&mpDXGIFactory ); if( FAILED(hr) ) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create a DXGIFactory for the swap chain", "D3D10RenderWindow::createD3DResources"); } // get the dxgi device IDXGIDevice* pDXGIDevice = NULL; hr = mDevice->QueryInterface( IID_IDXGIDevice, (void**)&pDXGIDevice ); if( FAILED(hr) ) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create a DXGIDevice for the swap chain", "D3D10RenderWindow::createD3DResources"); } // Create swap chain hr = mpDXGIFactory->CreateSwapChain( pDXGIDevice,&md3dpp,&mpSwapChain); if (FAILED(hr)) { // Try a second time, may fail the first time due to back buffer count, // which will be corrected by the runtime hr = mpDXGIFactory->CreateSwapChain(pDXGIDevice,&md3dpp,&mpSwapChain); } if (FAILED(hr)) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create an additional swap chain", "D3D10RenderWindow::createD3DResources"); } // Store references to buffers for convenience //mpSwapChain->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface ); // Additional swap chains need their own depth buffer // to support resizing them hr = mpSwapChain->GetBuffer( 0, __uuidof( ID3D10Texture2D ), (LPVOID*)&mpBackBuffer ); if( FAILED(hr) ) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to Get Back Buffer for swap chain", "D3D10RenderWindow::createD3DResources"); } // get the backbuffer desc D3D10_TEXTURE2D_DESC BBDesc; mpBackBuffer->GetDesc( &BBDesc ); // create the render target view D3D10_RENDER_TARGET_VIEW_DESC RTVDesc; ZeroMemory( &RTVDesc, sizeof(RTVDesc) ); RTVDesc.Format = BBDesc.Format; RTVDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D; RTVDesc.Texture2D.MipSlice = 0; hr = mDevice->CreateRenderTargetView( mpBackBuffer, &RTVDesc, &mRenderTargetView ); if( FAILED(hr) ) { String errorDescription = mDevice.getErrorDescription(); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create rendertagert view\nError Description:" + errorDescription, "D3D10RenderWindow::createD3DResources"); } if (mIsDepthBuffered) { /* hr = mDevice->CreateDepthStencilSurface( mWidth, mHeight, md3dpp.AutoDepthStencilFormat, md3dpp.MultiSampleType, md3dpp.MultiSampleQuality, (md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL), &mpRenderZBuffer, NULL ); if (FAILED(hr)) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create a depth buffer for the swap chain", "D3D10RenderWindow::createD3DResources"); } */ // get the backbuffer // Create depth stencil texture ID3D10Texture2D* pDepthStencil = NULL; D3D10_TEXTURE2D_DESC descDepth; descDepth.Width = mWidth; descDepth.Height = mHeight; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DXGI_FORMAT_R32_TYPELESS; descDepth.SampleDesc.Count = 1; descDepth.SampleDesc.Quality = 0; descDepth.Usage = D3D10_USAGE_DEFAULT; descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL; descDepth.CPUAccessFlags = 0; descDepth.MiscFlags = 0; hr = mDevice->CreateTexture2D( &descDepth, NULL, &pDepthStencil ); if( FAILED(hr) || mDevice.isError()) { String errorDescription = mDevice.getErrorDescription(hr); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create depth texture\nError Description:" + errorDescription, "D3D10RenderWindow::createD3DResources"); } // Create the depth stencil view D3D10_DEPTH_STENCIL_VIEW_DESC descDSV; descDSV.Format = DXGI_FORMAT_D32_FLOAT; descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; hr = mDevice->CreateDepthStencilView( pDepthStencil, &descDSV, &mDepthStencilView ); SAFE_RELEASE( pDepthStencil ); if( FAILED(hr) ) { String errorDescription = mDevice.getErrorDescription(); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to create depth stencil view\nError Description:" + errorDescription, "D3D10RenderWindow::createD3DResources"); } } else { // mpRenderZBuffer = 0; } } /*else { if (!mDevice) { // We haven't created the device yet, this must be the first time // Do we want to preserve the FPU mode? Might be useful for scientific apps DWORD extraFlags = 0; ConfigOptionMap& options = Root::getSingleton().getRenderSystem()->getConfigOptions(); ConfigOptionMap::iterator opti = options.find("Floating-point mode"); if (opti != options.end() && opti->second.currentValue == "Consistent") extraFlags |= D3DCREATE_FPU_PRESERVE; #if OGRE_THREAD_SUPPORT extraFlags |= D3DCREATE_MULTITHREADED; #endif // Set default settings (use the one Ogre discovered as a default) UINT adapterToUse = mDriver->getAdapterNumber(); if (mUseNVPerfHUD) { // Look for 'NVIDIA NVPerfHUD' adapter (<= v4) // or 'NVIDIA PerfHUD' (v5) // If it is present, override default settings for (UINT adapter=0; adapter < mDriver->getD3D()->GetAdapterCount(); ++adapter) { D3DADAPTER_IDENTIFIER9 identifier; HRESULT res; res = mDriver->getD3D()->GetAdapterIdentifier(adapter,0,&identifier); if (strstr(identifier.Description,"PerfHUD") != 0) { adapterToUse = adapter; devType = D3DDEVTYPE_REF; break; } } } hr = pD3D->CreateDevice(adapterToUse, devType, mHWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING | extraFlags, &md3dpp, &mDevice ); if (FAILED(hr)) { // Try a second time, may fail the first time due to back buffer count, // which will be corrected down to 1 by the runtime hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING | extraFlags, &md3dpp, &mDevice ); } if( FAILED( hr ) ) { hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd, D3DCREATE_MIXED_VERTEXPROCESSING | extraFlags, &md3dpp, &mDevice ); if( FAILED( hr ) ) { hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING | extraFlags, &md3dpp, &mDevice ); } } // TODO: make this a bit better e.g. go from pure vertex processing to software if( FAILED( hr ) ) { destroy(); OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Failed to create Direct3D9 Device: " + Root::getSingleton().getErrorDescription(hr), "D3D10RenderWindow::createD3DResources" ); } } // update device in driver mDriver->setD3DDevice( mDevice ); // Store references to buffers for convenience mDevice->GetRenderTarget( 0, &mpRenderSurface ); mDevice->GetDepthStencilSurface( &mpRenderZBuffer ); // release immediately so we don't hog them mpRenderZBuffer->Release(); } */ }
// ´ÙÀÌ·ºÆ® °´Ã¼ ÃʱâÈ // - °¢Á¾±â´ÉÀ» Áö¿øÇϴ°¡ üũÇÏ°í(´ÙÁß »ùÇøµ µî), ½º¿ÒüÀÎ, ÄÄ °´Ã¼ µîÀ» »ý¼º, Á¦°ÅÇÑ´Ù. bool cInitD3D::InitDirect3D() { // µð¹ÙÀ̽º, µð¹ÙÀ̽º ÄÁÅؽºÆ® »ý¼º UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevel; HRESULT hr = D3D11CreateDevice( 0, // default adapter md3dDriverType, 0, // no software device createDeviceFlags, 0, 0, // default feature level array D3D11_SDK_VERSION, &md3dDevice, &featureLevel, &md3dImmediateContext); if (FAILED(hr)) { MessageBox(0, L"D3D11CreateDevice Failed.", 0, 0); return false; } if (featureLevel != D3D_FEATURE_LEVEL_11_0) { MessageBox(0, L"Direct3D Feature Level 11 unsupported.", 0, 0); return false; } // ¹é¹öÆÛ¿¡ 4X MSAA Ç°Áú Áö¿øÀ» È®ÀÎ HR(md3dDevice->CheckMultisampleQualityLevels( DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m4xMsaaQuality)); assert(m4xMsaaQuality > 0); // ½º¿ÒüÀÎ »ý¼º DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = mClientWidth; sd.BufferDesc.Height = mClientHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // ´ÙÁß »ùÇøµ À¯¹« (Use 4X MSAA?) if (mEnable4xMsaa) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m4xMsaaQuality - 1; } // No MSAA else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } // ¹öÆÛ »ý¼º sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = mhMainWnd; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // µð¹ÙÀ̽º »ý¼º IDXGIDevice* dxgiDevice = 0; HR(md3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice)); IDXGIAdapter* dxgiAdapter = 0; HR(dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); IDXGIFactory* dxgiFactory = 0; HR(dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory)); // ½º¿ÒüÀÎ »ý¼º ¹× È®ÀÎ HR(dxgiFactory->CreateSwapChain(md3dDevice, &sd, &mSwapChain)); // ÄÄ °´Ã¼ »èÁ¦ ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); // â Å©±â Á¶Àý (ÄÚµå Áߺ¹ ÇÇÇϱâ À§ÇØ »ç¿ë) OnResize(); return true; }
void DirectXController::Initialize( void ) { WindowController::Get()->Initialize(); WindowController::Get()->OpenWindow(); driverType = D3D_DRIVER_TYPE_HARDWARE; enable4xMsaa = false; msaa4xQuality = 0; device.dx = nullptr; deviceContext.dx = nullptr; swapChain = nullptr; depthStencilBuffer = nullptr; renderTargetView = nullptr; depthStencilView = nullptr; ZeroMemory( &viewport, sizeof(D3D11_VIEWPORT) ); UINT createDeviceFlags = 0; #if defined(_DEBUG) || defined(DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL requiredFeatureLevel = D3D_FEATURE_LEVEL_11_0; D3D_FEATURE_LEVEL featureLevel; HRESULT hResult = D3D11CreateDevice( NULL, // Adapter driverType, // Driver Type NULL, // Software createDeviceFlags, // Flags &requiredFeatureLevel, // Feature levels 1, // num Feature levels D3D11_SDK_VERSION, // SDK Version &device.dx, // Device &featureLevel, // Feature Level &deviceContext.dx ); // Device Context // Handle any device creation or DirectX version errors if( FAILED(hResult) ) { MessageBox(NULL, L"D3D11CreateDevice Failed", NULL, NULL); //return false; } if( featureLevel != requiredFeatureLevel ) { MessageBox(NULL, L"Direct3D Feature Level 11 unsupported", NULL, NULL); //return false; } // Check for 4X MSAA quality support HR(device.dx->CheckMultisampleQualityLevels( DXGI_FORMAT_R8G8B8A8_UNORM, 4, &msaa4xQuality)); //assert( msaa4xQuality > 0 ); // Potential problem if quality is 0 // set up swap chain DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc) ); swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = WindowController::Get()->GetWidth();//windowWidth; swapChainDesc.BufferDesc.Height = WindowController::Get()->GetHeight();//windowHeight; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = Win32Controller::Get()->GetHWnd();//hMainWnd; swapChainDesc.Windowed = true; swapChainDesc.Flags = 0; if( enable4xMsaa ) { // Set up 4x MSAA swapChainDesc.SampleDesc.Count = 4; swapChainDesc.SampleDesc.Quality = msaa4xQuality - 1; } else { // No MSAA swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; } // To correctly create the swap chain, we must use the IDXGIFactory that // was used to create the device. IDXGIDevice* dxgiDevice = 0; IDXGIAdapter* dxgiAdapter = 0; IDXGIFactory* dxgiFactory = 0; HR(device.dx->QueryInterface( __uuidof(IDXGIDevice), (void**)&dxgiDevice)); HR(dxgiDevice->GetParent( __uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); HR(dxgiAdapter->GetParent( __uuidof(IDXGIFactory), (void**)&dxgiFactory)); // Finally make the swap chain and release the DXGI stuff HR(dxgiFactory->CreateSwapChain(device.dx, &swapChainDesc, &swapChain)); ReleaseCOMobjMacro(dxgiDevice); ReleaseCOMobjMacro(dxgiAdapter); ReleaseCOMobjMacro(dxgiFactory); // The remaining steps also need to happen each time the window // is resized, so just run the OnResize method Resize(); }
bool D3DApp::InitDirect3D() { /* ----------------------------------------- Create the D3D11 Device and DeviceContext ----------------------------------------- */ /* ----------------------- //? D3D11CreateDevice Notes ----------------------- //! Function Signature HRESULT result = D3D11CreateDevice( pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, SDKVersion, ppDevice, pFeatureLevel, ppImmediateContext ); //! Parameter Descriptions // The display adapter we want the created device to represent // Notes: Specifying "null" indicates the primary display adapter. //! IDXGIAdapter* pAdapter; // Type of driver our device will represent // Notes: In general, this should always be D3D_DRIVER_TYPE_HARDWARE, unless you need a reference, software, or WARP device. //! D3D_DRIVER_TYPE DriverType; // Software Driver // Notes: This is "null" if using a hardware driver. //! HMODULE Software; // (Optional) Device creation flags // Ex: D3D11_CREATE_DEVICE_DEBUG - Enables the Debug Layer, Direct3D will send debug messages to the VC++ output window. // Ex: D3D11_CREATE_DEVICE_SINGLETHREADED - Improves performance if you guarantee that Direct3D will not be called from multiple threads. //! UINT Flags; // Array of D3D feature levels // Notes: The order indicates the order in which to check for feature level support. // Specifying "null" indicates to choose the greatest feature level supported. //! const D3D_FEATURE_LEVEL* pFeatureLevels; // Size of pFeatureLevels array. // Notes: Specify "0" if you specified "null" for pFeatureLevels. //! UINT FeatureLevels; // Direct3D SDK Version // Notes: While studying this book, always use D3D11_SDK_VERSION. //! UINT SDKVersion; // Returns: Pointer to the device which this function will create //! ID3D11Device** ppDevice; // Returns: The first (highest) supported feature level from pFeatureLevels //! D3D_FEATURE_LEVEL* pFeatureLevel; // Returns: The created device context //! ID3D11DeviceContext** ppImmediateContext; */ UINT CreateDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) CreateDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL FeatureLevel; HRESULT CreateDeviceResult = D3D11CreateDevice( nullptr, mD3DDriverType, nullptr, CreateDeviceFlags, nullptr, 0, D3D11_SDK_VERSION, &mDevice, &FeatureLevel, &mImmediateContext ); if (FAILED(CreateDeviceResult)) { MessageBox(0, L"D3D11CreateDevice failed.", 0, 0); return false; } if (FeatureLevel != D3D_FEATURE_LEVEL_11_0) { MessageBox(0, L"Direct3D Feature Level 11 unsupported.", 0, 0); return false; } /* ----------------------------------- Check 4X MSAA Quality Level Support ----------------------------------- */ HR(mDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &mMultisampleQuality)); assert(mMultisampleQuality > 0); /* ---------------------------------------------- Describe the characteristics of the swap chain ---------------------------------------------- */ /* -------------------------- //? DXGI_SWAP_CHAIN_DESC Notes -------------------------- //! Structure Signature typedef struct DXGI_SWAP_CHAIN_DESC { DXGI_MODE_DESC BufferDesc; DXGI_SAMPLE_DESC SampleDesc; DXGI_USAGE BufferUsage; UINT BufferCount; HWND OutputWindow; BOOL Windowed; DXGI_SWAP_EFFECT SwapEffect; UINT Flags; } DXGI_SWAP_CHAIN_DESC; //! Member Descriptions // Properties of the back buffer // Notes: The main properties that concern us are the width, height, and pixel format. //! DXGI_MODE_DESC BufferDesc; // Number of multisamples and quality level //! DXGI_SAMPLE_DESC SampleDesc; // Usage of the back buffer // Notes: Specify DXGI_USAGE_RENDER_TARGET_OUTPUT to indicate that the back buffer will be used for rendering. //! DXGI_USAGE BufferUsage; // Number of back buffers in the swap chain // Notes: Use "1" to allocate one back buffer (double buffering) //! UINT BufferCount; // Handle to the window we are rendering to //! HWND OutputWindow; // Notes: "true" indicates windowed-mode, "false" indicates full-screen mode //! BOOL Windowed; // Notes: Specify DXGI_SWAP_EFFECT_DISCARD to let the display driver select the most efficient presentation method //! DXGI_SWAP_EFFECT SwapEffect; // (Optional) flags // Notes: If you use DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH, then when you switch to full-screen mode, the application // will select a display mode that best matches the current back buffer settings. //! UINT Flags; */ DXGI_SWAP_CHAIN_DESC SwapChainDesc; /* -------------------------- //? DXGI_DESC_MODE Notes -------------------------- //! Structure Signature typedef struct DXGI_MODE_DESC { UINT Width; UINT Height; DXGI_RATIONAL RefreshRate; DXGI_FORMAT Format; DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; DXGI_MODE_SCALING Scaling; } DXGI_MODE_DESC; //! Member Descriptions // Window resolution width //! UINT Width; // Window resolution height //! UINT Height; // Refresh rate defined in Hz (Numerator and Denominator) //! DXGI_RATIONAL RefreshRate; // Display format //! DXGI_FORMAT Format; // Scanline Drawing Mode //! DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; // Scaling Mode // Notes: Indicates how an image is stretched to fit the screen resolution. //! DXGI_MODE_SCALING Scaling; */ DXGI_MODE_DESC BackBufferDesc; BackBufferDesc.Width = 800; BackBufferDesc.Height = 600; // Most monitors cannot output more than 24-bit color, so extra precision would be wasted // Even though the monitor cannot output the 8-bit alpha, those bits can be used for other things like effects BackBufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; BackBufferDesc.RefreshRate.Numerator = 60; BackBufferDesc.RefreshRate.Denominator = 1; BackBufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; BackBufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; SwapChainDesc.BufferDesc = BackBufferDesc; if (mEnableMultisample) { SwapChainDesc.SampleDesc.Count = 4; SwapChainDesc.SampleDesc.Quality = mMultisampleQuality - 1; } else { SwapChainDesc.SampleDesc.Count = 1; SwapChainDesc.SampleDesc.Quality = 0; } SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; SwapChainDesc.BufferCount = 1; SwapChainDesc.OutputWindow = mMainWindow; SwapChainDesc.Windowed = true; SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; SwapChainDesc.Flags = 0; /* --------------------- Create the swap chain --------------------- */ IDXGIDevice* dxgiDevice = 0; mDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); IDXGIAdapter* dxgiAdapter = 0; dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); IDXGIFactory* dxgiFactory = 0; dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); dxgiFactory->CreateSwapChain(mDevice, &SwapChainDesc, &mSwapChain); ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); OnResize(); return true; }
bool DirectX11Graphics::Initialise() { if ( _is_initialised ) { //LogError( "F11", "Cannot initialise F11Graphics; F11Graphics is currently initialised." ); return false; } // Return false if no game has been set. if ( !GetGame() ) { //LogError( "F11", "Cannot initialise F11Graphics; F11Graphics has no graphics message listener set." ); return false; } // Get the dimensions of the screen. RECT rectangle; GetClientRect( HWND(GetGame()->GetHWND()), &rectangle ); unsigned int width = rectangle.right - rectangle.left; unsigned int height = rectangle.bottom - rectangle.top; if ( VRIsEnabled() ) { GetGame()->GetVRTextureDimensions( width, height ); } // Use the default adapter and hardware drivers. IDXGIFactory* factory = nullptr; IDXGIAdapter* adapter = nullptr; auto f = CreateDXGIFactory( __uuidof(IDXGIFactory), (void**)&factory ); auto a = factory->EnumAdapters( 0, &adapter ); // Create a debug device if in debug mode. #ifdef _DEBUG unsigned int device_flags = D3D11_CREATE_DEVICE_DEBUG; #else unsigned int device_flags = 0; #endif // Create a swap chain description. DXGI_SWAP_CHAIN_DESC swap_chain_desc; memset( &swap_chain_desc, 0, sizeof(swap_chain_desc) ); swap_chain_desc.BufferDesc.Width = width; swap_chain_desc.BufferDesc.Height = height; swap_chain_desc.BufferDesc.RefreshRate.Numerator = 0; swap_chain_desc.BufferDesc.RefreshRate.Denominator = 1; swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; //swap_chain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; //swap_chain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_CENTERED; 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 = HWND(GetGame()->GetHWND()); swap_chain_desc.Windowed = true; swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; swap_chain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // Create the swap chain, device and immediate device context. if ( FAILED( D3D11CreateDevice( adapter, adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, nullptr, device_flags, nullptr, 0, D3D11_SDK_VERSION, &_device, nullptr, &_immediate_device_context ) ) ) { //LogError( "F11", "Cannot initialise F11Graphics; cannot create device and swapchain." ); return false; } if ( adapter ) { adapter->Release(); } if ( FAILED( factory->CreateSwapChain( _device, &swap_chain_desc, &_swap_chain ) ) ) { return false; } ID3D11Texture2D* backbuffer = nullptr; HRESULT hr = _swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backbuffer); if (FAILED(hr)) return false; hr = _device->CreateRenderTargetView(backbuffer, nullptr, &_back_buffer); if (FAILED(hr)) return false; SetWidth( width ); SetHeight( height ); if ( backbuffer ) { backbuffer->Release(); } if ( factory ) { factory->Release(); } if ( VRIsEnabled() ) { { D3D11_BUFFER_DESC cbuffer_desc; cbuffer_desc.ByteWidth = sizeof(OculusBlit_cbuffer); cbuffer_desc.Usage = D3D11_USAGE_DYNAMIC; cbuffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbuffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; cbuffer_desc.MiscFlags = 0; cbuffer_desc.StructureByteStride = sizeof(OculusBlit_cbuffer); if ( FAILED( Device()->CreateBuffer( &cbuffer_desc, nullptr, &_oculus_blit_cbuffer ) ) ) { return false; } } _swap_chain->SetFullscreenState( 1, nullptr ); } if (0) { // Get the dxgi factory and disable fullscreen toggling with alt+enter. IDXGIDevice* dxgi_device = nullptr; if ( FAILED( _device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgi_device) ) ) { //LogError( "F11", "Cannot initialise F11Graphics; cannot get DXGI device." ); return false; } if ( FAILED( dxgi_device->GetParent(__uuidof(IDXGIAdapter), (void **)&adapter) ) ) { //LogError( "F11", "Cannot initialise F11Graphics; cannot get DXGI adapter." ); return false; } IDXGIFactory * factory = nullptr; if ( FAILED( adapter->GetParent(__uuidof(IDXGIFactory), (void **)&factory) ) ) { //LogError( "F11", "Cannot initialise F11Graphics; cannot get DXGI factory." ); return false; } factory->MakeWindowAssociation( HWND(GetGame()->GetHWND()), DXGI_MWA_NO_WINDOW_CHANGES ); dxgi_device->Release(); adapter->Release(); factory->Release(); } // Create the back buffer by resizing //Resize( width, height ); _resources.SetConfig(GetGraphicsSettings()); if ( !_resources.Initialise() ) { return false; } Resize( width, height ); _is_initialised = true; return true; }
egl::Error DXGISwapChainWindowSurfaceWGL::createSwapChain() { egl::Error error = setObjectsLocked(false); if (error.isError()) { return error; } if (mRenderbufferBufferHandle) { mFunctionsWGL->dxUnregisterObjectNV(mDeviceHandle, mRenderbufferBufferHandle); mRenderbufferBufferHandle = nullptr; } // If this surface is bound to a texture, unregister it. bool hadBoundSurface = (mTextureHandle != nullptr); if (hadBoundSurface) { mFunctionsWGL->dxUnregisterObjectNV(mDeviceHandle, mTextureHandle); mTextureHandle = nullptr; } IDXGIFactory *dxgiFactory = GetDXGIFactoryFromDevice(mDevice); if (dxgiFactory == nullptr) { return egl::Error(EGL_BAD_NATIVE_WINDOW, "Failed to query the DXGIFactory."); } IDXGIFactory2 *dxgiFactory2 = nullptr; HRESULT result = dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void **>(&dxgiFactory2)); if (SUCCEEDED(result)) { ASSERT(dxgiFactory2 != nullptr); DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0}; swapChainDesc.BufferCount = 1; swapChainDesc.Format = mSwapChainFormat; swapChainDesc.Width = static_cast<UINT>(mWidth); swapChainDesc.Height = static_cast<UINT>(mHeight); swapChainDesc.Format = mSwapChainFormat; swapChainDesc.Stereo = FALSE; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER; swapChainDesc.BufferCount = 1; swapChainDesc.Scaling = DXGI_SCALING_STRETCH; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; swapChainDesc.Flags = mSwapChainFlags; result = dxgiFactory2->CreateSwapChainForHwnd(mDevice, mWindow, &swapChainDesc, nullptr, nullptr, &mSwapChain1); SafeRelease(dxgiFactory2); SafeRelease(dxgiFactory); if (FAILED(result)) { return egl::Error(EGL_BAD_ALLOC, "Failed to create swap chain for window, result: 0x%X", result); } mSwapChain = mSwapChain1; mSwapChain->AddRef(); } else { DXGI_SWAP_CHAIN_DESC swapChainDesc = {}; swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Format = mSwapChainFormat; swapChainDesc.BufferDesc.Width = static_cast<UINT>(mWidth); swapChainDesc.BufferDesc.Height = static_cast<UINT>(mHeight); swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER; swapChainDesc.Flags = mSwapChainFlags; swapChainDesc.OutputWindow = mWindow; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.Windowed = TRUE; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; result = dxgiFactory->CreateSwapChain(mDevice, &swapChainDesc, &mSwapChain); SafeRelease(dxgiFactory); if (FAILED(result)) { return egl::Error(EGL_BAD_ALLOC, "Failed to create swap chain for window, result: 0x%X", result); } } ID3D11Texture2D *colorBuffer = nullptr; result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void **>(&colorBuffer)); if (FAILED(result)) { return egl::Error(EGL_BAD_ALLOC, "Failed to query texture from swap chain, result: 0x%X", result); } mFunctionsGL->genRenderbuffers(1, &mColorRenderbufferID); mStateManager->bindRenderbuffer(GL_RENDERBUFFER, mColorRenderbufferID); mRenderbufferBufferHandle = mFunctionsWGL->dxRegisterObjectNV(mDeviceHandle, colorBuffer, mColorRenderbufferID, GL_RENDERBUFFER, WGL_ACCESS_READ_WRITE_NV); SafeRelease(colorBuffer); if (mRenderbufferBufferHandle == nullptr) { return egl::Error(EGL_BAD_ALLOC, "Failed to register D3D object, error: 0x%X.", HRESULT_CODE(GetLastError())); } // Rebind the surface to the texture if needed. if (hadBoundSurface) { mTextureHandle = mFunctionsWGL->dxRegisterObjectNV(mDeviceHandle, colorBuffer, mTextureID, GL_TEXTURE_2D, WGL_ACCESS_READ_WRITE_NV); if (mTextureHandle == nullptr) { return egl::Error(EGL_BAD_ALLOC, "Failed to register D3D object, error: 0x%X.", HRESULT_CODE(GetLastError())); } } error = setObjectsLocked(true); if (error.isError()) { return error; } ASSERT(mFramebufferID != 0); mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID); mFunctionsGL->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mColorRenderbufferID); if (mDepthBufferFormat != GL_NONE) { ASSERT(mDepthRenderbufferID != 0); mStateManager->bindRenderbuffer(GL_RENDERBUFFER, mDepthRenderbufferID); mFunctionsGL->renderbufferStorage(GL_RENDERBUFFER, mDepthBufferFormat, static_cast<GLsizei>(mWidth), static_cast<GLsizei>(mHeight)); const gl::InternalFormat &depthStencilFormatInfo = gl::GetInternalFormatInfo(mDepthBufferFormat); if (depthStencilFormatInfo.depthBits > 0) { mFunctionsGL->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthRenderbufferID); } if (depthStencilFormatInfo.stencilBits > 0) { mFunctionsGL->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, mDepthRenderbufferID); } } mFirstSwap = true; return egl::Error(EGL_SUCCESS); }
bool Direct3D::Initialize(HWND* hWnd) { mcWidth = &Settings->GetData()->mWidth; mcHeight = &Settings->GetData()->mHeight; UINT createDeviceFlags = 0; #if defined(_DEBUG) | (DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevel; if( FAILED ( D3D11CreateDevice( nullptr, mDriverType, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &mDevice, &featureLevel, &mDevCon))) { cout << "D3D11CreateDevice failed." << endl; return false; } if(featureLevel != D3D_FEATURE_LEVEL_11_0) { cout << "Direct3D feature level 11 unsupported." << endl; return false; } mDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m4xMSAAQuality); assert(m4xMSAAQuality > 0); DXGI_SWAP_CHAIN_DESC sd = {}; sd.BufferDesc.Width = *mcWidth; sd.BufferDesc.Height = *mcHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if (mEnable4xMsaa) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m4xMSAAQuality-1; } else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // Use back buffer as render target sd.BufferCount = 1; // Number of back buffers to use in swap chain sd.OutputWindow = *hWnd; // Specify window we render into sd.Windowed = !Settings->GetData()->mIsFullscreen; // Windowed mode or full-screen mode sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // Let display driver select most efficient presentation method sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; IDXGIDevice* dxgiDevice = nullptr; mDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); IDXGIAdapter* dxgiAdapter = nullptr; dxgiDevice->GetParent(__uuidof(IDXGIAdapter),(void**)&dxgiAdapter); IDXGIFactory* dxgiFactory = nullptr; dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); dxgiFactory->CreateSwapChain(mDevice, &sd, &mSwapChain); SafeRelease(dxgiDevice); SafeRelease(dxgiAdapter); SafeRelease(dxgiFactory); this->OnResize(); return true; }
bool DXApp::InitDirectX() { UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featurelvl; HRESULT hr = D3D11CreateDevice( 0, //default adapter D3D_DRIVER_TYPE_HARDWARE, 0, createDeviceFlags, 0, 0, D3D11_SDK_VERSION, &m_d3dDevice, &featurelvl, &m_d3dImmediateContext); if (FAILED(hr)) { MessageBox(0, L"Creation of Context failed", 0, 0); return false; } if (featurelvl != D3D_FEATURE_LEVEL_11_0) { MessageBox(0, L"DirectX11 not supported", 0, 0); return false; } m_d3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m_4xMsaaQuality); assert(m_4xMsaaQuality > 0); DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = m_clientWidth; sd.BufferDesc.Height = m_clientHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if (m_enable4xMsaa) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m_4xMsaaQuality - 1; } else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = m_4xMsaaQuality - 1; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow =m_mainHandle; sd.Windowed = m_windowed; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; IDXGIDevice* dxgiDevice = 0; m_d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); IDXGIAdapter* dxgiAdapter = 0; dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); IDXGIFactory* dxgiFactory = 0; dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); dxgiFactory->CreateSwapChain(m_d3dDevice, &sd, &m_d3dSwapChain); //NO ALT-ENTER dxgiFactory->MakeWindowAssociation(m_mainHandle, DXGI_MWA_NO_ALT_ENTER); UINT i = 0; IDXGIAdapter* pAdapter; std::vector<IDXGIAdapter*> vAdapters; while (dxgiFactory->EnumAdapters(i, &pAdapter) != DXGI_ERROR_NOT_FOUND) { vAdapters.push_back(pAdapter); //pAdapter->CheckInterfaceSupport(__uuidof(DIRECT3D_VERSION), DIRECT3D_11.0); i++; } //MessageBox(0, LPCWSTR(std::to_string(vAdapters.size()).c_str()), 0, 0); for (auto a : vAdapters)a->Release(); dxgiDevice->Release(); dxgiAdapter->Release(); dxgiFactory->Release(); ID3D11Texture2D* backBuffer; m_d3dSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer)); m_d3dDevice->CreateRenderTargetView(backBuffer, 0, &m_d3dRenderTargetView); backBuffer->Release(); D3D11_TEXTURE2D_DESC depthStencilDesc; depthStencilDesc.Width = m_clientWidth; depthStencilDesc.Height = m_clientHeight; depthStencilDesc.MipLevels = 1; depthStencilDesc.ArraySize = 1; depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; if (m_enable4xMsaa) { depthStencilDesc.SampleDesc.Count = 4; depthStencilDesc.SampleDesc.Quality = m_4xMsaaQuality - 1; } else { depthStencilDesc.SampleDesc.Count = 1; depthStencilDesc.SampleDesc.Quality = m_4xMsaaQuality - 0; } depthStencilDesc.Usage = D3D11_USAGE_DEFAULT; depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; depthStencilDesc.CPUAccessFlags = 0; depthStencilDesc.MiscFlags = 0; m_d3dDevice->CreateTexture2D(&depthStencilDesc, 0, &m_d3dDepthStencilBuffer); m_d3dDevice->CreateDepthStencilView(m_d3dDepthStencilBuffer, 0, &m_d3dDepthStencilView); m_d3dImmediateContext->OMSetRenderTargets(1, &m_d3dRenderTargetView, m_d3dDepthStencilView); D3D11_VIEWPORT vp; vp.TopLeftX = 0.f; vp.TopLeftY = 0.f; vp.Width = static_cast<float>(m_clientWidth); vp.Height = static_cast<float>(m_clientHeight); vp.MinDepth = 0.f; vp.MaxDepth = 0.f; m_d3dImmediateContext->RSSetViewports(1, &vp); return true; }
bool BasicRenderer::initD3D() { unsigned int createDeviceFlags = 0; # if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; # endif D3D_FEATURE_LEVEL featureLevel; HRESULT hr = D3D11CreateDevice( 0, m_driverType, 0, createDeviceFlags, 0, 0, D3D11_SDK_VERSION, &m_device, &featureLevel, &m_context); if (FAILED(hr)) { return false; } if (featureLevel != D3D_FEATURE_LEVEL_11_0) { return false; } m_device->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m_4xMSAAQuality); assert(m_4xMSAAQuality > 0); DXGI_SWAP_CHAIN_DESC swapChainDesc; swapChainDesc.BufferDesc.Width = m_width; swapChainDesc.BufferDesc.Height = m_height; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if( m_enable4xMSAA ) { swapChainDesc.SampleDesc.Count = 4; swapChainDesc.SampleDesc.Quality = m_4xMSAAQuality-1; } else { swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; } swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 1; swapChainDesc.OutputWindow = reinterpret_cast<HWND>(m_windowHandle); swapChainDesc.Windowed = true; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; IDXGIDevice* dxgiDevice = 0; m_device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); IDXGIDevice* dxgiAdapter = 0; dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); IDXGIFactory* dxgiFactory = 0; dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); dxgiFactory->CreateSwapChain(m_device, &swapChainDesc, &m_swapChain); releaseCOM(dxgiDevice); releaseCOM(dxgiAdapter); releaseCOM(dxgiFactory); onResize(); return true; }
// Direct3Dの初期化 HRESULT InitD3D( void ) { HRESULT hr = S_OK; D3D_FEATURE_LEVEL FeatureLevelsRequested[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 }; UINT numLevelsRequested = 6; D3D_FEATURE_LEVEL FeatureLevelsSupported; // デバイス作成 hr = D3D11CreateDevice( NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, FeatureLevelsRequested, numLevelsRequested, D3D11_SDK_VERSION, &g_pd3dDevice, &FeatureLevelsSupported, &g_pImmediateContext ); if( FAILED ( hr ) ) { return hr; } // ファクトリの取得 IDXGIDevice * pDXGIDevice; hr = g_pd3dDevice->QueryInterface( __uuidof( IDXGIDevice ), ( void ** )&pDXGIDevice ); IDXGIAdapter * pDXGIAdapter; hr = pDXGIDevice->GetParent( __uuidof( IDXGIAdapter ), ( void ** )&pDXGIAdapter ); IDXGIFactory * pIDXGIFactory; pDXGIAdapter->GetParent( __uuidof( IDXGIFactory ), ( void ** )&pIDXGIFactory); // スワップチェインの作成 DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; sd.BufferDesc.Width = g_nClientWidth; sd.BufferDesc.Height = g_nClientHeight; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = g_hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; hr = pIDXGIFactory->CreateSwapChain( g_pd3dDevice, &sd, &g_pSwapChain ); pDXGIDevice->Release(); pDXGIAdapter->Release(); pIDXGIFactory->Release(); if( FAILED ( hr ) ) { return hr; } // レンダリングターゲットの生成 ID3D11Texture2D *pBackBuffer = NULL; D3D11_TEXTURE2D_DESC BackBufferSurfaceDesc; hr = g_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't get backbuffer." ), _T( "Error" ), MB_OK ); return hr; } pBackBuffer->GetDesc( &BackBufferSurfaceDesc ); hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, NULL, &g_pRTV ); SAFE_RELEASE( pBackBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create render target view." ), _T( "Error" ), MB_OK ); return hr; } g_pImmediateContext->OMSetRenderTargets( 1, &g_pRTV, NULL ); // ラスタライザの設定 D3D11_RASTERIZER_DESC drd; ZeroMemory( &drd, sizeof( drd ) ); drd.FillMode = D3D11_FILL_SOLID; drd.CullMode = D3D11_CULL_NONE; drd.FrontCounterClockwise = FALSE; drd.DepthClipEnable = TRUE; hr = g_pd3dDevice->CreateRasterizerState( &drd, &g_pRS ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create rasterizer state." ), _T( "Error" ), MB_OK ); return hr; } g_pImmediateContext->RSSetState( g_pRS ); // ビューポートの設定 D3D11_VIEWPORT vp; vp.Width = ( FLOAT )g_nClientWidth; vp.Height = ( FLOAT )g_nClientHeight; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0.0f; vp.TopLeftY = 0.0f; g_pImmediateContext->RSSetViewports( 1, &vp ); return S_OK; }
bool D3DApp::InitDirect3D() { // Create the device and device context. UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevel; HRESULT hr = D3D11CreateDevice( 0, // default adapter md3dDriverType, 0, // no software device createDeviceFlags, 0, 0, // default feature level array D3D11_SDK_VERSION, &md3dDevice, &featureLevel, &md3dImmediateContext); if( FAILED(hr) ) { MessageBox(0, L"D3D11CreateDevice Failed.", 0, 0); return false; } if( featureLevel != D3D_FEATURE_LEVEL_11_0 ) { MessageBox(0, L"Direct3D Feature Level 11 unsupported.", 0, 0); return false; } // Check 4X MSAA quality support for our back buffer format. // All Direct3D 11 capable devices support 4X MSAA for all render // target formats, so we only need to check quality support. HR(md3dDevice->CheckMultisampleQualityLevels( DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m4xMsaaQuality)); assert( m4xMsaaQuality > 0 ); // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(DXGI_SWAP_CHAIN_DESC)); sd.BufferDesc.Width = mClientWidth; sd.BufferDesc.Height = mClientHeight; sd.Windowed = true; sd.BufferDesc.RefreshRate.Numerator = m_MonitorNumerator; sd.BufferDesc.RefreshRate.Denominator = m_MonitorDenumerator; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Use 4X MSAA? if( mEnable4xMsaa ) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m4xMsaaQuality-1; } // No MSAA else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = mhMainWnd; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // To correctly create the swap chain, we must use the IDXGIFactory that was // used to create the device. If we tried to use a different IDXGIFactory instance // (by calling CreateDXGIFactory), we get an error: "IDXGIFactory::CreateSwapChain: // This function is being called with a device from a different IDXGIFactory." IDXGIDevice* dxgiDevice = 0; HR(md3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice)); IDXGIAdapter* dxgiAdapter = 0; HR(dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); IDXGIFactory* dxgiFactory = 0; HR(dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory)); HR(dxgiFactory->CreateSwapChain(md3dDevice, &sd, &mSwapChain)); //Disable Alt-Enter Sequence dxgiFactory->MakeWindowAssociation(mhMainWnd, DXGI_MWA_NO_ALT_ENTER); ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); // The remaining steps that need to be carried out for d3d creation // also need to be executed every time the window is resized. So // just call the OnResize method here to avoid code duplication. OnResize(); if (mFullScreen){ mSwapChain->SetFullscreenState(true, NULL); } return true; }
bool D3DRenderer::CreateSwapChain(int screenWidth, int screenHeight, HWND hwnd) { //Get refresh rate, display modes, and initialize the swap chain. HRESULT result; IDXGIDevice* dxgiDevice = 0; IDXGIFactory* dxgiFactory =0; IDXGIAdapter* dxgiAdapter =0; IDXGIOutput* dxgiAdapterOutput; unsigned int numModes, i, numerator, denominator, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; DXGI_SWAP_CHAIN_DESC swapChainDesc; this->m_device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); result = dxgiFactory->EnumAdapters(0, &dxgiAdapter); if (FAILED(result)) { return false; } result = dxgiAdapter->EnumOutputs(0, &dxgiAdapterOutput); if (FAILED(result)) { return false; } result = dxgiAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL); if (FAILED(result)) { return false; } displayModeList = new DXGI_MODE_DESC[numModes]; if (!displayModeList) { return false; } result = dxgiAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if (FAILED(result)) { return false; } 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; } } } result = dxgiAdapter->GetDesc(&adapterDesc); if (FAILED(result)) { return false; } this->m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); error = wcstombs_s(&stringLength, this->m_videoCardDescription, 128, adapterDesc.Description, 128); if (error != 0) { return false; } //Initialize the swap chain ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); //Single buffer count swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = screenWidth; swapChainDesc.BufferDesc.Height = screenHeight; //Using regular 32bit back buffer swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; if (this->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 swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = hwnd; //Turn multisamping off. This setting is for MSAA, for our purposes we don't need it. swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.Windowed = true; //Set the scan line ordering swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; //Tells D3D to discard the back buffer after presenting swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; //Do not use advanced flags. swapChainDesc.Flags = 0; //Create the swap chain result = dxgiFactory->CreateSwapChain(this->m_device, &swapChainDesc, &this->m_swapChain); if (FAILED(result)) { return false; } delete [] displayModeList; displayModeList = 0; dxgiAdapterOutput->Release(); dxgiAdapterOutput = 0; dxgiAdapter->Release(); dxgiAdapter = 0; dxgiFactory->Release(); dxgiFactory = 0; return true; }
// Direct3Dの初期化 HRESULT InitD3D( void ) { HRESULT hr = S_OK; D3D_FEATURE_LEVEL FeatureLevelsRequested[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 }; UINT numLevelsRequested = 6; D3D_FEATURE_LEVEL FeatureLevelsSupported; // デバイス作成 hr = D3D11CreateDevice( NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, FeatureLevelsRequested, numLevelsRequested, D3D11_SDK_VERSION, &g_pd3dDevice, &FeatureLevelsSupported, &g_pImmediateContext ); if( FAILED ( hr ) ) { return hr; } // ファクトリの取得 IDXGIDevice * pDXGIDevice; hr = g_pd3dDevice->QueryInterface( __uuidof( IDXGIDevice ), ( void ** )&pDXGIDevice ); IDXGIAdapter * pDXGIAdapter; hr = pDXGIDevice->GetParent( __uuidof( IDXGIAdapter ), ( void ** )&pDXGIAdapter ); IDXGIFactory * pIDXGIFactory; pDXGIAdapter->GetParent( __uuidof( IDXGIFactory ), ( void ** )&pIDXGIFactory); // スワップチェインの作成 DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; sd.BufferDesc.Width = g_nClientWidth; sd.BufferDesc.Height = g_nClientHeight; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = g_hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; hr = pIDXGIFactory->CreateSwapChain( g_pd3dDevice, &sd, &g_pSwapChain ); pDXGIDevice->Release(); pDXGIAdapter->Release(); pIDXGIFactory->Release(); if( FAILED ( hr ) ) { return hr; } // レンダリングターゲットの生成 ID3D11Texture2D *pBackBuffer = NULL; D3D11_TEXTURE2D_DESC BackBufferSurfaceDesc; hr = g_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't get backbuffer." ), _T( "Error" ), MB_OK ); return hr; } pBackBuffer->GetDesc( &BackBufferSurfaceDesc ); hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, NULL, &g_pRTV ); SAFE_RELEASE( pBackBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create render target view." ), _T( "Error" ), MB_OK ); return hr; } // *** Create depth stencil texture *** D3D11_TEXTURE2D_DESC descDepth; RECT rc; GetClientRect( g_hWnd, &rc ); ZeroMemory( &descDepth, sizeof(descDepth) ); descDepth.Width = rc.right - rc.left; descDepth.Height = rc.bottom - rc.top; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; descDepth.SampleDesc.Count = 1; descDepth.SampleDesc.Quality = 0; descDepth.Usage = D3D11_USAGE_DEFAULT; descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL; descDepth.CPUAccessFlags = 0; descDepth.MiscFlags = 0; hr = g_pd3dDevice->CreateTexture2D( &descDepth, NULL, &g_pDepthStencil ); if( FAILED( hr ) ) return hr; // *** Create the depth stencil view *** D3D11_DEPTH_STENCIL_VIEW_DESC descDSV; ZeroMemory( &descDSV, sizeof(descDSV) ); descDSV.Format = descDepth.Format; descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; hr = g_pd3dDevice->CreateDepthStencilView( g_pDepthStencil, &descDSV, &g_pDepthStencilView ); if( FAILED( hr ) ) return hr; // *** レンダリングターゲット設定 *** g_pImmediateContext->OMSetRenderTargets( 1, &g_pRTV, g_pDepthStencilView ); // ステンシルステートの作成 D3D11_DEPTH_STENCIL_DESC dsDesc; // Depth test parameters dsDesc.DepthEnable = true; dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; dsDesc.DepthFunc = D3D11_COMPARISON_LESS; // Stencil test parameters dsDesc.StencilEnable = true; dsDesc.StencilReadMask = 0xFF; dsDesc.StencilWriteMask = 0xFF; // Stencil operations if pixel is front-facing dsDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; dsDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; dsDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; dsDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Stencil operations if pixel is back-facing dsDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; dsDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; dsDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; dsDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Create depth stencil state hr = g_pd3dDevice->CreateDepthStencilState( &dsDesc, &g_pDSDepthState ); dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO; hr = g_pd3dDevice->CreateDepthStencilState( &dsDesc, &g_pDSDepthState_NoWrite ); // g_pImmediateContext->OMSetDepthStencilState( g_pDSDepthState, 1 ); // ラスタライザの設定 D3D11_RASTERIZER_DESC drd; ZeroMemory( &drd, sizeof( drd ) ); drd.FillMode = D3D11_FILL_SOLID; drd.CullMode = D3D11_CULL_NONE; drd.FrontCounterClockwise = FALSE; drd.DepthClipEnable = TRUE; hr = g_pd3dDevice->CreateRasterizerState( &drd, &g_pRS ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create rasterizer state." ), _T( "Error" ), MB_OK ); return hr; } g_pImmediateContext->RSSetState( g_pRS ); // ラスタライザの設定(時計回りカリング) ZeroMemory( &drd, sizeof( drd ) ); drd.FillMode = D3D11_FILL_SOLID; drd.CullMode = D3D11_CULL_BACK; drd.FrontCounterClockwise = TRUE; drd.DepthClipEnable = TRUE; hr = g_pd3dDevice->CreateRasterizerState( &drd, &g_pRS_Cull_CW ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create rasterizer state." ), _T( "Error" ), MB_OK ); return hr; } // g_pImmediateContext->RSSetState( g_pRS_Cull_CW ); // ラスタライザの設定(反時計回りカリング) ZeroMemory( &drd, sizeof( drd ) ); drd.FillMode = D3D11_FILL_SOLID; drd.CullMode = D3D11_CULL_BACK; drd.FrontCounterClockwise = FALSE; drd.DepthClipEnable = TRUE; hr = g_pd3dDevice->CreateRasterizerState( &drd, &g_pRS_Cull_CCW ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't create rasterizer state." ), _T( "Error" ), MB_OK ); return hr; } // g_pImmediateContext->RSSetState( g_pRS_Cull_CCW ); // ビューポートの設定 D3D11_VIEWPORT vp; vp.Width = ( FLOAT )g_nClientWidth; vp.Height = ( FLOAT )g_nClientHeight; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0.0f; vp.TopLeftY = 0.0f; g_pImmediateContext->RSSetViewports( 1, &vp ); return S_OK; }
bool D3DRenderWidget::createDevice() { HRESULT re; // 函数返回值, HRESULT 是一种简单的数据类型,通常被属性和 ATL 用作返回值。 UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevel; // Direct3D 设备的功能级别目标 HRESULT hr = D3D11CreateDevice( 0, m_d3dDriverType, 0, createDeviceFlags, 0, 0, D3D11_SDK_VERSION, &m_d3dDevice, &featureLevel, &m_d3dImmediateContext); if (FAILED(hr)) { MessageBox(0, L"D3D11CreateDevice Failed.", 0, 0); return false; } if (featureLevel != D3D_FEATURE_LEVEL_11_0) { MessageBox(0, L"Direct3D Feature Level 11 unsupported.", 0, 0); return false; } re = m_d3dDevice->CheckMultisampleQualityLevels( DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m_4xMsaaQuality); if (FAILED(re)) return false; assert(m_4xMsaaQuality > 0); DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = width(); sd.BufferDesc.Height = height(); sd.BufferDesc.RefreshRate.Numerator = 60; // 分子 sd.BufferDesc.RefreshRate.Denominator = 1; // 分母 sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if (m_enable4xMsaa) { sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = m_4xMsaaQuality - 1; } else { sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; } sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = (HWND)winId(); sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; IDXGIDevice* dxgiDevice = 0; re = m_d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); if (FAILED(re)) return false; IDXGIAdapter* dxgiAdapter = 0; re = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); if (FAILED(re)) return false; IDXGIFactory* dxgiFactory = 0; re = dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); if (FAILED(re)) return false; re = dxgiFactory->CreateSwapChain(m_d3dDevice, &sd, &m_swapChain); if (FAILED(re)) return false; safe_release(dxgiDevice); safe_release(dxgiAdapter); safe_release(dxgiFactory); return true; }
HRESULT KGraphicsDevice::Init(int32 window_width, int32 window_height) { HRESULT hr; m_WindowWidth = window_width; m_WindowHeight = window_height; //Setup SDL window HWND handle; if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0) { shared_context.log->LogText(LogLevel::FATAL_ERROR, "SDL_Init failed: %s", SDL_GetError()); } IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF); m_MainWindow = SDL_CreateWindow("Conservative Clustered Shading DirectX12", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, m_WindowWidth, m_WindowHeight, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); SDL_SysWMinfo info; //Must init info struct with SDL version info, see documentation for explanation SDL_VERSION(&info.version); if (SDL_GetWindowWMInfo(m_MainWindow, &info)) handle = info.info.win.window; else shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to get WMInfo: %s", SDL_GetError()); uint32 flags = 0; #ifdef _DEBUG { ID3D12Debug* debugController; D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)); debugController->EnableDebugLayer(); if (debugController) debugController->Release(); } #endif DXGI_SWAP_CHAIN_DESC descSwapChain; ZeroMemory(&descSwapChain, sizeof(descSwapChain)); descSwapChain.BufferCount = 2; descSwapChain.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; descSwapChain.BufferUsage = DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_RENDER_TARGET_OUTPUT; descSwapChain.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; descSwapChain.OutputWindow = handle; descSwapChain.SampleDesc.Count = 1; descSwapChain.Windowed = true; hr = D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_Device)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to create D3D12 Device"); D3D12_FEATURE_DATA_D3D12_OPTIONS opts; hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &opts, sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to CheckFeatureSupport"); //Print hardware opts PrintHWopts(opts); uint32 node_count = m_Device->GetNodeCount(); shared_context.log->LogText(LogLevel::DEBUG_PRINT, "Device node count: %d", node_count); IDXGIFactory* dxgifactory; hr = CreateDXGIFactory1(IID_PPV_ARGS(&dxgifactory)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to create IDXGIFactory"); D3D12_COMMAND_QUEUE_DESC queueDesc; ZeroMemory(&queueDesc, sizeof(queueDesc)); queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; hr = m_Device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_CommandQueue)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to create Command Queue"); hr = dxgifactory->CreateSwapChain(m_CommandQueue, &descSwapChain, &m_SwapChain); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to create SwapChain"); dxgifactory->Release(); //Set up descriptor heaps m_DescHeapCBV_SRV.CreateDescriptorHeap(50, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE); m_DescHeapDSV.CreateDescriptorHeap(2, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, D3D12_DESCRIPTOR_HEAP_FLAG_NONE); m_DescHeapRTV.CreateDescriptorHeap(20, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, D3D12_DESCRIPTOR_HEAP_FLAG_NONE); m_DescHeapSampler.CreateDescriptorHeap(1, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE); m_Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_CommandAllocator)); m_Device->SetStablePowerState(TRUE); hr = m_CommandQueue->GetTimestampFrequency(&m_Freq); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed GetTimestampFrequency"); m_ViewPort = { 0.0f, 0.0f, (float)m_WindowWidth, (float)m_WindowHeight, 0.0f, 1.0f }; m_ScissorRect = { 0, 0, m_WindowWidth, m_WindowHeight }; m_RTDescriptor[0] = m_DescHeapRTV.GetNewCPUHandle(); m_RTDescriptor[1] = m_DescHeapRTV.GetNewCPUHandle(); //Get back buffer and create RTVs m_SwapChain->GetBuffer(0, IID_PPV_ARGS(&m_RenderTarget[0])); m_Device->CreateRenderTargetView(m_RenderTarget[0], nullptr, m_RTDescriptor[0]); m_RenderTarget[0]->SetName(L"RENDER TARGET"); m_SwapChain->GetBuffer(1, IID_PPV_ARGS(&m_RenderTarget[1])); m_Device->CreateRenderTargetView(m_RenderTarget[1], nullptr, m_RTDescriptor[1]); //Create time stamp query heap const uint32 num_time_queries = 24; D3D12_QUERY_HEAP_DESC desc; desc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP; desc.Count = num_time_queries; desc.NodeMask = 0; hr = m_Device->CreateQueryHeap(&desc, IID_PPV_ARGS(&m_TimeStampQueryHeap)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to CreateQueryHeap"); m_Device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK, 0, 0), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(num_time_queries * sizeof(uint64)), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_TimeStampQueryReadBackRes)); if (FAILED(hr)) shared_context.log->LogText(LogLevel::FATAL_ERROR, "Failed to CreateCommittedResource for query readback buffer"); //Create fence m_Device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_Fence)); m_CurrentFence = 1; m_HandleEvent = CreateEventEx(nullptr, FALSE, FALSE, EVENT_ALL_ACCESS); return hr; }
HRESULT ACD3D::AddViewport(HWND hWnd, BOOL enableVSync) { HRESULT hr; VSyncEnable = enableVSync; Log("Add viewport"); //cria o retangulo para renderizacao RECT rc; GetClientRect( hWnd, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; //adiciona os objetos necessarios para cada vp ACD3DVpComponents* vpComponent = new ACD3DVpComponents(); //pega o factory IDXGIFactory* pDXGIFactory = ACD3DTools::GetDXGIFactory(); #pragma region CREATE SWAP CHAIN IDXGISwapChain* pSwapChain; //define o rendertargetview, define o buffer e coloca como backbuffer em cada swapchain //cria os swpachains para cada janela DXGI_SWAP_CHAIN_DESC scd; SecureZeroMemory(&scd, sizeof(scd)); if (VSyncEnable) scd = ACD3DConfigurations::DefineSwapShain(hWnd, width, height, ACD3DGlobals::G_Numerator, ACD3DGlobals::G_Denomerator); //ser form o vsync enable ele sincroniza a renderizacao com o refreshrate da tela else scd = ACD3DConfigurations::DefineSwapShain(hWnd, width, height, 60, 1); //senao ele usa direto os valores padroes isso pode gerar alguns artefatos MF hr = pDXGIFactory->CreateSwapChain(ACD3DGlobals::G_pD3dDevice, &scd, &pSwapChain); if( FAILED( hr ) ) { MessageBoxA(nullptr, "[ERROR] Creating SwapChain. AddViewport()", "Error", MB_OK | MB_ICONERROR); return hr; } // Release the factory. pDXGIFactory->Release(); pDXGIFactory = nullptr; vpComponent->pSwapChain = pSwapChain; #pragma endregion #pragma region CREATE RENDERTARGETVIEW //array de backbuffers, um pra cada janela ID3D11Texture2D* pBackBuffer; ID3D11RenderTargetView* pRenderTargetView; hr = pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer ); if( FAILED( hr ) ) { MessageBoxA(nullptr, "[ERROR] Create buffer. AddViewport()", "Error", MB_OK | MB_ICONERROR); return hr; } hr = ACD3DGlobals::G_pD3dDevice->CreateRenderTargetView( pBackBuffer, nullptr, &pRenderTargetView ); if( FAILED( hr ) ) { MessageBoxA(nullptr, "[ERROR] Create render target. AddViewport()", "Error", MB_OK | MB_ICONERROR); return hr; } vpComponent->pRenderTargetView = pRenderTargetView; pBackBuffer->Release(); #pragma endregion #pragma region CREATE DEPTHSTENCILVIEW ID3D11Texture2D* pDepthStencil; ID3D11DepthStencilView* pDepthStencilView; //define o stencil view hr = ACD3DConfigurations::DefineDepthStencilView(ACD3DGlobals::G_pD3dDevice, &pDepthStencil, &pDepthStencilView, width, height); if( FAILED( hr ) ) { MessageBoxA(nullptr, "[ERROR] Create depth stencil view. AddViewport()", "Error", MB_OK | MB_ICONERROR); return hr; } vpComponent->pDepthStencilView = pDepthStencilView; pDepthStencil->Release(); #pragma endregion #pragma region CREATE VIEWPORT D3D11_VIEWPORT vp; ACD3DConfigurations::DefineViewPort(width, height, 0, 1, rc.left, rc.top, &vp); vpComponent->Viewport = vp; #pragma endregion //inser o objeto no map mpVpComponents.insert(std::pair<HWND, ACD3DVpComponents*>(hWnd, vpComponent)); //seta a viewport ACD3DGlobals::G_pContext->RSSetViewports( 1, &vp ); //seta o render target e o depthstencil ACD3DGlobals::G_pContext->OMSetRenderTargets( 1, &pRenderTargetView, pDepthStencilView ); SetActiveViewport(hWnd); SetActiveRenderingViewport(hWnd); return AC_OK; };
bool Renderer::Init() { UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) //createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; //createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUGGABLE; #endif D3D_FEATURE_LEVEL featureLevel; HRESULT hresult = D3D11CreateDevice(0, _d3dDriverType, 0, createDeviceFlags, 0, 0, D3D11_SDK_VERSION, &_d3dDevice, &featureLevel, &_d3dImmediateContext); if (FAILED(hresult)) { // TODO: Throw exceptions _logger.LogLine(L"Failed to initialize Renderer: Failed to create D3D11CreateDevice."); _logger.LogHResult(hresult); MessageBox(0, L"Failed to initialize Renderer, see log for details.", 0, 0); return false; } if (featureLevel != D3D_FEATURE_LEVEL_11_0) //if (featureLevel != 0xc000) { // TODO: Throw exceptions _logger.LogLine(L"Failed to initialize Renderer: Required D3D feature level 11 not supported."); MessageBox(0, L"Failed to initialize Renderer, see log for details.", 0, 0); return false; } hresult = (_d3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &_4xMsaaQuality)); if (FAILED(hresult)) { _logger.LogHResult(hresult); } assert(_4xMsaaQuality > 0); DXGI_SWAP_CHAIN_DESC swapChainDescription; swapChainDescription.BufferDesc.Width = _clientWidth; swapChainDescription.BufferDesc.Height = _clientHeight; swapChainDescription.BufferDesc.RefreshRate.Numerator = 60; swapChainDescription.BufferDesc.RefreshRate.Denominator = 1; swapChainDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; if (_enable4xMsaa) { swapChainDescription.SampleDesc.Count = 4; swapChainDescription.SampleDesc.Quality = _4xMsaaQuality - 1; } else { swapChainDescription.SampleDesc.Count = 1; swapChainDescription.SampleDesc.Quality = 0; } swapChainDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDescription.BufferCount = 1; swapChainDescription.OutputWindow = _windowHandle; swapChainDescription.Windowed = true; swapChainDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDescription.Flags = 0; IDXGIDevice* dxgiDevice = 0; hresult = (_d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice)); if (FAILED(hresult)) { _logger.LogHResult(hresult); } IDXGIAdapter* dxgiAdapter = 0; hresult = (dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter)); if (FAILED(hresult)) { _logger.LogHResult(hresult); } IDXGIFactory* dxgiFactory = 0; hresult = (dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory)); if (FAILED(hresult)) { _logger.LogHResult(hresult); } hresult = (dxgiFactory->CreateSwapChain(_d3dDevice, &swapChainDescription, &_swapChain)); if (FAILED(hresult)) { _logger.LogHResult(hresult); } if (dxgiDevice) { dxgiDevice->Release(); dxgiDevice = 0; } if (dxgiAdapter) { dxgiAdapter->Release(); dxgiAdapter = 0; } if (dxgiFactory) { dxgiFactory->Release(); dxgiFactory = 0; } OnResize(); return true; }