HRESULT DeviceResources::OnSizeChanged(HWND hWnd, DWORD dwWidth, DWORD dwHeight) { HRESULT hr; char* step = ""; this->_depthStencilView.Release(); this->_depthStencil.Release(); this->_renderTargetView.Release(); this->_offscreenBuffer.Release(); this->_backBuffer.Release(); this->_swapChain.Release(); DXGI_RATIONAL t = { 0, 1 }; this->_refreshRate = t; if (hWnd != nullptr) { step = "RenderTarget SwapChain"; ComPtr<IDXGIDevice> dxgiDevice; ComPtr<IDXGIAdapter> dxgiAdapter; ComPtr<IDXGIOutput> dxgiOutput; hr = this->_d3dDevice.As(&dxgiDevice); if (SUCCEEDED(hr)) { hr = dxgiDevice->GetAdapter(&dxgiAdapter); if (SUCCEEDED(hr)) { hr = dxgiAdapter->EnumOutputs(0, &dxgiOutput); } } DXGI_MODE_DESC md; memset(&md, 0, sizeof(DXGI_MODE_DESC)); if (SUCCEEDED(hr)) { md.Format = DXGI_FORMAT_B8G8R8A8_UNORM; hr = dxgiOutput->FindClosestMatchingMode(&md, &md, nullptr); } if (SUCCEEDED(hr)) { DXGI_SWAP_CHAIN_DESC sd; memset(&sd, 0, sizeof(DXGI_SWAP_CHAIN_DESC)); sd.BufferCount = 2; sd.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; sd.BufferDesc.Width = 0; sd.BufferDesc.Height = 0; sd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; sd.BufferDesc.RefreshRate = md.RefreshRate; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; ComPtr<IDXGIFactory> dxgiFactory; hr = dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory)); if (SUCCEEDED(hr)) { hr = dxgiFactory->CreateSwapChain(this->_d3dDevice, &sd, &this->_swapChain); } if (SUCCEEDED(hr)) { this->_refreshRate = sd.BufferDesc.RefreshRate; } } if (SUCCEEDED(hr)) { hr = this->_swapChain->GetBuffer(0, IID_PPV_ARGS(&this->_backBuffer)); } } else { step = "RenderTarget Texture2D"; CD3D11_TEXTURE2D_DESC backBufferDesc( DXGI_FORMAT_B8G8R8A8_UNORM, dwWidth, dwHeight, 1, 1, D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT, 0, 1, 0, 0); hr = this->_d3dDevice->CreateTexture2D(&backBufferDesc, nullptr, &this->_backBuffer); } if (SUCCEEDED(hr)) { D3D11_TEXTURE2D_DESC backBufferDesc; this->_backBuffer->GetDesc(&backBufferDesc); this->_backbufferWidth = backBufferDesc.Width; this->_backbufferHeight = backBufferDesc.Height; } if (SUCCEEDED(hr)) { step = "OffscreenBuffer"; CD3D11_TEXTURE2D_DESC desc( DXGI_FORMAT_B8G8R8A8_UNORM, this->_backbufferWidth, this->_backbufferHeight, 1, 1, D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT, 0, this->_sampleDesc.Count, this->_sampleDesc.Quality, 0); hr = this->_d3dDevice->CreateTexture2D(&desc, nullptr, &this->_offscreenBuffer); } if (SUCCEEDED(hr)) { step = "RenderTargetView"; CD3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc(this->_useMultisampling ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D); hr = this->_d3dDevice->CreateRenderTargetView(this->_offscreenBuffer, &renderTargetViewDesc, &this->_renderTargetView); } if (SUCCEEDED(hr)) { step = "DepthStencil"; D3D11_TEXTURE2D_DESC depthStencilDesc; depthStencilDesc.Width = this->_backbufferWidth; depthStencilDesc.Height = this->_backbufferHeight; depthStencilDesc.MipLevels = 1; depthStencilDesc.ArraySize = 1; depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthStencilDesc.SampleDesc.Count = this->_sampleDesc.Count; depthStencilDesc.SampleDesc.Quality = this->_sampleDesc.Quality; depthStencilDesc.Usage = D3D11_USAGE_DEFAULT; depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; depthStencilDesc.CPUAccessFlags = 0; depthStencilDesc.MiscFlags = 0; hr = this->_d3dDevice->CreateTexture2D(&depthStencilDesc, nullptr, &this->_depthStencil); if (SUCCEEDED(hr)) { step = "DepthStencilView"; CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(this->_useMultisampling ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D); hr = this->_d3dDevice->CreateDepthStencilView(this->_depthStencil, &depthStencilViewDesc, &this->_depthStencilView); } } if (SUCCEEDED(hr)) { step = "Viewport"; this->_d3dDeviceContext->OMSetRenderTargets(1, this->_renderTargetView.GetAddressOf(), this->_depthStencilView.Get()); D3D11_VIEWPORT viewport; viewport.TopLeftX = 0; viewport.TopLeftY = 0; viewport.Width = (float)this->_backbufferWidth; viewport.Height = (float)this->_backbufferHeight; viewport.MinDepth = D3D11_MIN_DEPTH; viewport.MaxDepth = D3D11_MAX_DEPTH; this->_d3dDeviceContext->RSSetViewports(1, &viewport); } if (SUCCEEDED(hr)) { step = "Texture2D"; D3D11_TEXTURE2D_DESC textureDesc; textureDesc.Width = this->_displayWidth; textureDesc.Height = this->_displayHeight; textureDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; textureDesc.Usage = D3D11_USAGE_DYNAMIC; textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; textureDesc.MiscFlags = 0; textureDesc.MipLevels = 1; textureDesc.ArraySize = 1; textureDesc.SampleDesc.Count = 1; textureDesc.SampleDesc.Quality = 0; textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; hr = this->_d3dDevice->CreateTexture2D(&textureDesc, nullptr, &this->_mainDisplayTexture); if (SUCCEEDED(hr)) { D3D11_SHADER_RESOURCE_VIEW_DESC textureViewDesc; memset(&textureViewDesc, 0, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC)); textureViewDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; textureViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; textureViewDesc.Texture2D.MipLevels = 1; textureViewDesc.Texture2D.MostDetailedMip = 0; hr = this->_d3dDevice->CreateShaderResourceView(this->_mainDisplayTexture, &textureViewDesc, &this->_mainDisplayTextureView); } } if (FAILED(hr)) { static bool messageShown = false; if (!messageShown) { char text[512]; strcpy_s(text, step); strcat_s(text, "\n"); strcat_s(text, _com_error(hr).ErrorMessage()); MessageBox(nullptr, text, __FUNCTION__, MB_ICONERROR); } messageShown = true; } return hr; }
int ContextD3D11::CreateWindowSizeDependentResources(uint32_t width, uint32_t height) { ID3D11RenderTargetView* nullViews[] = {nullptr}; device_context_->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr); SafeRelease(&render_target_view_); SafeRelease(&depth_stencil_view_); device_context_->Flush(); //RECT rc; //GetClientRect( window_handle_, &rc ); width_ = width;//rc.right - rc.left; height_ = height;//rc.bottom - rc.top; if(swap_chain_ != nullptr) { swap_chain_->ResizeBuffers(2, static_cast<UINT>(width_),static_cast<UINT>(height_), DXGI_FORMAT_B8G8R8A8_UNORM, 0); } else { // Otherwise, create a new one using the same adapter as the existing Direct3D device. DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0}; swapChainDesc.Width = static_cast<UINT>(width_); // Match the size of the window. swapChainDesc.Height = static_cast<UINT>(height_); swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain format. swapChainDesc.Stereo = false; swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling. swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency. swapChainDesc.Scaling = DXGI_SCALING_NONE; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect. swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; IDXGIDevice1* dxgiDevice; device_->QueryInterface(__uuidof(dxgiDevice),(void**)&dxgiDevice); //IDXGIAdapter* dxgiAdapter; //dxgiDevice->GetAdapter(&dxgiAdapter); IDXGIFactory2* dxgiFactory; adaptor_->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory ); DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc; memset(&fullscreen_desc,0,sizeof(fullscreen_desc)); fullscreen_desc.Windowed = true; dxgiFactory->CreateSwapChainForHwnd(device_,window_handle_, &swapChainDesc, &fullscreen_desc,nullptr, &swap_chain_); dxgiDevice->SetMaximumFrameLatency(1); SafeRelease(&dxgiFactory); //SafeRelease(&dxgiAdapter); SafeRelease(&dxgiDevice); } ID3D11Texture2D* backBuffer; swap_chain_->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&backBuffer); device_->CreateRenderTargetView(backBuffer,nullptr,&render_target_view_); SafeRelease(&backBuffer); // Create a depth stencil view. CD3D11_TEXTURE2D_DESC depthStencilTextureDesc( DXGI_FORMAT_D24_UNORM_S8_UINT, static_cast<UINT>(width_), static_cast<UINT>(height_), 1, 0, D3D11_BIND_DEPTH_STENCIL ); ID3D11Texture2D* depth_stencil_tex; device_->CreateTexture2D(&depthStencilTextureDesc,nullptr,&depth_stencil_tex); CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D); device_->CreateDepthStencilView(depth_stencil_tex,&depthStencilViewDesc,&depth_stencil_view_); SafeRelease(&depth_stencil_tex); SafeRelease(&default_depth_state); D3D11_DEPTH_STENCIL_DESC depthStencilDesc; // Initialize the description of the stencil state. ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc)); depthStencilDesc.DepthEnable = true; depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS; depthStencilDesc.StencilEnable = true; depthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; depthStencilDesc.StencilWriteMask = 0xFF; // Stencil operations if pixel is front-facing. depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Stencil operations if pixel is back-facing. depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; device_->CreateDepthStencilState(&depthStencilDesc, &default_depth_state); SetDepthState(null,0); // Set the rendering viewport to target the entire window. CD3D11_VIEWPORT viewport(0.0f,0.0f,width_,height_); device_context_->RSSetViewports(1, &viewport); device_context_->OMSetRenderTargets( 1, &render_target_view_, depth_stencil_view_ ); return S_OK; }
// TODO create software window bool RenderWindowD11_2::Create(const _lParametor& config) { _lParametor::const_iterator parametor; HRESULT hr = S_FALSE; auto divace = m_pRSystem->GetD3DDevice(); auto context = m_pRSystem->GetD3DDeviceContext(); // Î÷èñòèòü ïðåäûäóùàÿ ðàçìåð îêíà êîíêðåòíîãî êîíòåêñòà. ID3D11RenderTargetView* nullViews[] = { nullptr }; context->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr); m_d3dRenderTargetView = nullptr; m_d3dDepthStencilView = nullptr; context->Flush(); parametor = config.find("window_name"); if (parametor != config.end()) { mObjectName = parametor->second; } _32un bit = 0; parametor = config.find("display_mode"); if (parametor != config.end()) { StringConverter::ParseDisplyaMode(parametor->second, m_nWidth, m_nHeight, bit); } else { DrawLine("~RenderWindowD11_2: not set display_mode", MT_ERROR); return false; } parametor = config.find("full_screan_mode"); if (parametor != config.end()) { m_bFullScrean = StringConverter::Parse_bool(parametor->second); } else { DrawLine("~RenderWindowD11_2: not set full_screan_mode set in false"); m_bFullScrean = false; } parametor = config.find("window_handle"); if (parametor != config.end()) { m_hWnd = StringConverter::Parse_int(parametor->second); } else { DrawLine("~RenderWindowD11_2: not set window_handle", MT_ERROR); return false; } DXGI_SWAP_CHAIN_DESC1 swapChainDesc = { 0 }; swapChainDesc.Width = m_nWidth; swapChainDesc.Height = m_nHeight; swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // Ýòî íàèáîëåå ðàñïðîñòðàíåííûé ôîðìàò swap chain. swapChainDesc.Stereo = false; swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling. swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency. swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect. swapChainDesc.Flags = 0; swapChainDesc.Scaling = DXGI_SCALING_NONE; swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE; ComPtr<IDXGIDevice2> dxgiDevice; divace->QueryInterface(IID_PPV_ARGS(&dxgiDevice)); ComPtr<IDXGIAdapter> dxgiAdapter; dxgiDevice->GetAdapter(&dxgiAdapter); ComPtr<IDXGIFactory2> dxgiFactory; dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory)); hr = dxgiFactory->CreateSwapChainForHwnd( divace, // pDevice [in] (HWND)m_hWnd, // hWnd [in] &swapChainDesc, // pDesc [in] nullptr, // pFullscreenDesc [in, optional] nullptr, // pRestrictToOutput [in, optional] &m_swapChain // ppSwapChain [out] ); if (FAILED(hr)) { DrawLine("~RenderWindowD11_2: " + RenderSystemD11_2::GetErrorHR(hr), MT_ERROR); return false; } // Óáåäèòåñü, ÷òî DXGI íå ñòîÿòü â î÷åðåäè áîëüøå, ÷åì îäèí êàäð çà îäèí ðàç. Ýòî è ñîêðàùàåò çàäåðæêè è // Ãàðàíòèðóåò, ÷òî ïðèëîæåíèå áóäåò îêàçûâàòü òîëüêî ïîñëå êàæäîãî VSync, ìèíèìèçèðóÿ ïîòðåáëåíèå ýíåðãèè. dxgiDevice->SetMaximumFrameLatency(1); // Create a render target view of the swap chain back buffer. ComPtr<ID3D11Texture2D> backBuffer; m_swapChain->GetBuffer(0, IID_PPV_ARGS(&backBuffer)); divace->CreateRenderTargetView( backBuffer.Get(), nullptr, &m_d3dRenderTargetView ); // Create a depth stencil view for use with 3D rendering if needed. CD3D11_TEXTURE2D_DESC depthStencilDesc( DXGI_FORMAT_D24_UNORM_S8_UINT, m_nWidth, m_nHeight, 1, // This depth stencil view has only one texture. 1, // Use a single mipmap level. D3D11_BIND_DEPTH_STENCIL ); ComPtr<ID3D11Texture2D> depthStencil; divace->CreateTexture2D( &depthStencilDesc, nullptr, &depthStencil ); CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D); divace->CreateDepthStencilView( depthStencil.Get(), &depthStencilViewDesc, &m_d3dDepthStencilView ); // Set the 3D rendering viewport to target the entire window. m_screenViewport = CD3D11_VIEWPORT( 0.0f, 0.0f, (FLOAT)m_nWidth, (FLOAT)m_nHeight ); context->RSSetViewports(1, &m_screenViewport); m_bInit = true; return true; }
//! resizes the screen surface void DirectX11Driver::ResizeScreen(const Vector2& vSize) { if(m_Device.Get()) { ID3D11RenderTargetView* nullViews[] = { NULL }; m_ImmediateContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, NULL); m_RenderTargetView = NULL; m_DepthStencilView = NULL; m_SwapChain = NULL; m_MVPBuffer = NULL; m_TextureTransformBuffer = NULL; m_MaterialBuffer = NULL; m_TextureSamplerLinear = NULL; for(int i=0; i<2; ++i) { for(int j=0; j<D3D11_BLEND_INV_SRC1_ALPHA+1; ++j) { for(int k=0; k<D3D11_BLEND_INV_SRC1_ALPHA+1; ++k) { m_BlendState[i][j][k] = NULL; } } } for(int i=0; i<2; ++i) { for(int j=0; j<2; ++j) { for(int k=0; k<D3D11_COMPARISON_ALWAYS+1; ++k) { m_DepthStencilState[i][j][k] = NULL; } } } for(int i=0; i<2; ++i) { for(int j=0; j<D3D11_FILL_SOLID+1; ++j) { for(int k=0; k<D3D11_CULL_BACK+1; ++k) { m_RasterizerState[i][j][k] = NULL; } } } m_ImmediateContext->Flush(); DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0}; swapChainDesc.Width = newSize.Width; swapChainDesc.Height = newSize.Height; swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; swapChainDesc.Stereo = false; swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling. swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 1; // On phone, only single buffering is supported. swapChainDesc.Scaling = DXGI_SCALING_STRETCH; // On phone, only stretch and aspect-ratio stretch scaling are allowed. swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // On phone, no swap effects are supported. swapChainDesc.Flags = 0; COMReference<IDXGIDevice1> XGIDevice1; IDXGIDevice1* pIDXGIDevice1 = NULL; DX_ASSERT(m_Device->QueryInterface(__uuidof(IDXGIDevice1), (void**)&pIDXGIDevice1)); XGIDevice1 = pIDXGIDevice1; COMReference<IDXGIAdapter> XGIAdapter; IDXGIAdapter* pIDXGIAdapter = NULL; DX_ASSERT(XGIDevice1->GetAdapter(&pIDXGIAdapter)); XGIAdapter = pIDXGIAdapter; COMReference<IDXGIFactory2> XGIFactory2; IDXGIFactory2* pFactory = NULL; DX_ASSERT(XGIAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&pFactory)); XGIFactory2 = pFactory; // create swap chain IDXGISwapChain1* pSwapChain = NULL; #if SHOOT_PLATFORM == SHOOT_PLATFORM_WP8 DX_ASSERT(ShootCreateSwapChainForCoreWindow(XGIFactory2, m_Device, &swapChainDesc, &pSwapChain)); #else DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullScreenDesc; fullScreenDesc.RefreshRate.Numerator = 60; fullScreenDesc.RefreshRate.Denominator = 1; fullScreenDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; fullScreenDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; fullScreenDesc.Windowed = !App::Instance()->IsFullScreen(); DX_ASSERT(XGIFactory2->CreateSwapChainForHwnd(m_Device, m_hWindow, &swapChainDesc, &fullScreenDesc, NULL, &pSwapChain)); #endif m_SwapChain = pSwapChain; // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and // ensures that the application will only render after each VSync, minimizing power consumption. DX_ASSERT(XGIDevice1->SetMaximumFrameLatency(1)); // Create render target & depth stencil views COMReference<ID3D11Texture2D> backBuffer; ID3D11Texture2D* pBackBuffer = NULL; DX_ASSERT(m_SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer)); backBuffer = pBackBuffer; ID3D11RenderTargetView* pRenderTargetView = NULL; DX_ASSERT(m_Device->CreateRenderTargetView(backBuffer, NULL, &pRenderTargetView)); m_RenderTargetView = pRenderTargetView; COMReference<ID3D11Texture2D> depthStencil; ID3D11Texture2D* pDepthStencil = NULL; CD3D11_TEXTURE2D_DESC depthStencilDesc(DXGI_FORMAT_D24_UNORM_S8_UINT, newSize.Width, newSize.Height, 1, 1, D3D11_BIND_DEPTH_STENCIL); DX_ASSERT(m_Device->CreateTexture2D(&depthStencilDesc, NULL, &pDepthStencil)); depthStencil = pDepthStencil; CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D); ID3D11DepthStencilView* pDepthStencilView = NULL; DX_ASSERT(m_Device->CreateDepthStencilView(depthStencil, &depthStencilViewDesc, &pDepthStencilView)); m_DepthStencilView = pDepthStencilView; m_ImmediateContext->OMSetRenderTargets(1, &pRenderTargetView, m_DepthStencilView); m_RenderTargetView = pRenderTargetView; // create the constant buffers D3D11_BUFFER_DESC bd; ZeroMemory(&bd, sizeof(bd)); bd.Usage = D3D11_USAGE_DEFAULT; bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; bd.CPUAccessFlags = 0; bd.ByteWidth = sizeof(Matrix44); ID3D11Buffer* pMVP = NULL; DX_ASSERT(m_Device->CreateBuffer(&bd, NULL, &pMVP)); m_MVPBuffer = pMVP; bd.ByteWidth = sizeof(Matrix44); ID3D11Buffer* pTextureTransformBuffer = NULL; DX_ASSERT(m_Device->CreateBuffer(&bd, NULL, &pTextureTransformBuffer)); m_TextureTransformBuffer = pTextureTransformBuffer; bd.ByteWidth = sizeof(Color); ID3D11Buffer* pMaterialBuffer = NULL; DX_ASSERT(m_Device->CreateBuffer(&bd, NULL, &pMaterialBuffer)); m_MaterialBuffer = pMaterialBuffer; // Create the texture samplers D3D11_SAMPLER_DESC sampDesc; ZeroMemory( &sampDesc, sizeof(sampDesc) ); sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; sampDesc.MinLOD = 0; sampDesc.MaxLOD = D3D11_FLOAT32_MAX; ID3D11SamplerState* pSampler = NULL; DX_ASSERT(m_Device->CreateSamplerState(&sampDesc, &pSampler)); m_TextureSamplerLinear = pSampler; // Create blend state ZeroMemory(&m_BlendDesc, sizeof(D3D11_BLEND_DESC)); m_BlendDesc.RenderTarget[0].BlendEnable = false; m_BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; m_BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; m_BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; m_BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO; m_BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; m_BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; m_BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; ID3D11BlendState* pBlendState = NULL; DX_ASSERT(m_Device->CreateBlendState(&m_BlendDesc, &pBlendState)); m_BlendState[m_BlendDesc.RenderTarget[0].BlendEnable][m_BlendDesc.RenderTarget[0].SrcBlend][m_BlendDesc.RenderTarget[0].DestBlend] = pBlendState; // Create depth stencil state ZeroMemory(&m_DSDesc, sizeof(D3D11_DEPTH_STENCIL_DESC)); m_DSDesc.DepthEnable = true; m_DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; m_DSDesc.DepthFunc = D3D11_COMPARISON_LESS; m_DSDesc.StencilEnable = false; ID3D11DepthStencilState* pDepthStencilState = NULL; DX_ASSERT(m_Device->CreateDepthStencilState(&m_DSDesc, &pDepthStencilState)); m_DepthStencilState[m_DSDesc.DepthEnable][m_DSDesc.DepthWriteMask][m_DSDesc.DepthFunc] = pDepthStencilState; // Create the rasterizer state ZeroMemory(&m_RSDesc, sizeof(D3D11_RASTERIZER_DESC)); m_RSDesc.AntialiasedLineEnable = false; m_RSDesc.CullMode = D3D11_CULL_BACK; m_RSDesc.DepthBias = 0; m_RSDesc.DepthBiasClamp = 0.0f; m_RSDesc.DepthClipEnable = true; m_RSDesc.FillMode = D3D11_FILL_SOLID; m_RSDesc.FrontCounterClockwise = false; m_RSDesc.MultisampleEnable = false; m_RSDesc.ScissorEnable = false; m_RSDesc.SlopeScaledDepthBias = 0.0f; ID3D11RasterizerState* pRasterizerState = NULL; DX_ASSERT(m_Device->CreateRasterizerState(&m_RSDesc, &pRasterizerState)); m_RasterizerState[m_RSDesc.FrontCounterClockwise][m_RSDesc.FillMode][m_RSDesc.CullMode] = pRasterizerState; SetCullMode(CM_CounterClockWise); } super::ResizeScreen(newSize); }