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);
}
