void Renderer::RecreateSizeDependentBuffers()
{
CD3DX12_CPU_DESCRIPTOR_HANDLE RTVHandle(RTVHeap->GetCPUDescriptorHandleForHeapStart());
for (UINT i = 0; i < BufferFrameCount; ++i)
{
RenderTargets[i].CreateWindowSizeDependendResources(i, DeviceContext.GetDevice(), SwapChain, RTVHandle);
RTVHandle.Offset(RTVDescSize);
}
CreateDepthStencilView();
}
void DX11Engine::createSwapChainRenderTargets(IUnknown** ppRTV, IUnknown** ppRTVsRGB,
IUnknown** ppDSV, IUnknown* pNativeDevice, IUnknown* pSwapChainIn,
size_t length, const char* debugName) const
{
auto pSwapChain = reinterpret_cast<IDXGISwapChain*>(pSwapChainIn);
auto pDevice = reinterpret_cast<ID3D11Device*>(pNativeDevice);
HRESULT hr = S_OK;
std::unique_ptr<ID3D11Texture2D, COMDeleter> pD3D11Texture;
// rtv
DXGI_SWAP_CHAIN_DESC desc;
V(pSwapChain->GetDesc(&desc));
V(pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), ref(pD3D11Texture)));
STAR_SET_DEBUG_NAME(pD3D11Texture, length, debugName);
CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE2D);
rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
ID3D11RenderTargetView* pRTV;
V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
*ppRTV = pRTV;
STAR_SET_DEBUG_NAME(pRTV, length, debugName);
rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
*ppRTVsRGB = pRTV;
STAR_SET_DEBUG_STRING(pRTV, (debugName + std::string("_sRGB")));
// dsv
if(ppDSV) {
D3D11_TEXTURE2D_DESC descTex2D = {
desc.BufferDesc.Width,
desc.BufferDesc.Height,
1, 1, DXGI_FORMAT_D32_FLOAT,{ 1, 0 },
D3D11_USAGE_DEFAULT, D3D11_BIND_DEPTH_STENCIL,
0, 0
};
std::unique_ptr<ID3D11Texture2D, COMDeleter> pDST;
V(pDevice->CreateTexture2D(&descTex2D, nullptr, ref(pDST)));
STAR_SET_DEBUG_NAME(pDST, length, debugName);
D3D11_DEPTH_STENCIL_VIEW_DESC descV = {
DXGI_FORMAT_D32_FLOAT, D3D11_DSV_DIMENSION_TEXTURE2D, 0,{ 0 }
};
ID3D11DepthStencilView* pDSV;
V(pDevice->CreateDepthStencilView(pDST.get(), &descV, &pDSV));
*ppDSV = pDSV;
STAR_SET_DEBUG_NAME(pDSV, length, debugName);
}
}
void D3D::D3DResize(int screenWidth, int screenHeight)
{
//ReleaseCOM(m_renderTargetView);
//ReleaseCOM(m_depthStencilBuffer);
//ReleaseCOM(m_depthStencilView);
CreateRenderTargetView(screenWidth, screenHeight);
CreateDepthStencilBuffer(screenWidth, screenHeight);
CreateDepthStencilView();
m_renderTargetView->AddRef();
int ref = m_renderTargetView->Release();
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
SetViewport(screenWidth, screenHeight);
}
void D3DTexture2D::Initialize(int width, int height, DXGI_FORMAT format, UINT bind, UINT misc, const D3D11_SUBRESOURCE_DATA* data)
{
D3D11_TEXTURE2D_DESC desc;
this->width = width;
this->height = height;
SetupDefaultDescription(desc, width, height, format, bind, misc);
// 派生クラスによるオーバーライド
// この辺、付け焼刃な感じなので後で変える可能性あり
SetupDescription(desc);
auto device = core->GetDevice();
auto hresult = device->CreateTexture2D(&desc, data, &this->texture);
this->AddResource(HndToRes(texture));
if (bind & D3D10_BIND_SHADER_RESOURCE) { // ShaderResourceViewの作成
device->CreateShaderResourceView(texture, nullptr, &srv);
this->AddResource(HndToRes(srv));
}
else {
srv = nullptr;
}
if (bind & D3D10_BIND_RENDER_TARGET) { // RenderTargetViewの作成
device->CreateRenderTargetView(texture, nullptr, &rtv);
this->AddResource(HndToRes(rtv));
}
else {
rtv = nullptr;
}
if (bind & D3D10_BIND_DEPTH_STENCIL) { // DepthStencilViewの作成
device->CreateDepthStencilView(texture, nullptr, &dsv);
this->AddResource(HndToRes(dsv));
}
else {
dsv = nullptr;
}
}
HRESULT Device3D::Resize(INT32 Width, INT32 Height)
{
HRESULT hr = S_OK;
m_iWidth = Width;
m_iHeight = Height;
/*
SAFE_RELEASE(mTexture2D);
SAFE_RELEASE(mRenderTargetView);
SAFE_RELEASE(mDepthStencilView);
*/
if(mTexture2D)
{
while(mTexture2D->Release());
mTexture2D = NULL;
}
if(mRenderTargetView)
{
while(mRenderTargetView->Release());
mRenderTargetView = NULL;
}
if(mDepthStencilView)
{
while(mDepthStencilView->Release());
mDepthStencilView = NULL;
}
if(FAILED(CreateTargetView()))
return E_FAIL;
if(FAILED(CreateDepthStencilView()))
return E_FAIL;
SetViewport();
return hr;
}
void Renderer::Initialize()
{
if (TargetWindow.GetHandle() == nullptr)
{
Utility::Throw(L"Window Handle is invalid!");
}
CreateSwapChain();
CreateRTVHeap();
CreateDSVHeap();
CreateDepthStencilView();
InitializeRenderTargets();
CreateCommandList();
const Window::WindowSize & WindowSize = TargetWindow.GetWindowSize();
Camera.UpdateCamera(WindowSize);
UpdateViewportAndScissorRect(WindowSize);
Fence.Initialize(DeviceContext.GetDevice());
}
//--------------------------------------------------------------------------------------
// class DefaultRenderTarget : public RenderTarget;
// 用途: デフォルトのレンダーターゲット
// ＊デフォルトのレンダラー
//--------------------------------------------------------------------------------------
//構築
DefaultRenderTarget::DefaultRenderTarget(const shared_ptr<Stage>& stage) :
pImpl(new Impl(stage))
{
try{
if (pImpl->m_Stage.expired()){
throw BaseException(
L"ステージが無効です",
L"if (pImpl->m_Stage.expired())",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
}
auto Dev = App::GetApp()->GetDeviceResources();
auto pD3D11Device = Dev->GetD3DDevice();
auto pSwapChain = Dev->GetSwapChain();
auto pD3D11DeviceContext = Dev->GetD3DDeviceContext();
auto pD2D11DeviceContext = Dev->GetD2DDeviceContext();
//レンダリングターゲットビューの作成
ComPtr<ID3D11Texture2D> pBackBuffer;
//まずバックバッファのポインタを得る
ThrowIfFailed(
pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer),
L"スワップチェーンからバックバッファの取得に失敗しました。",
L"pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer)",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
//バックバッファからレンダリングターゲットのビューを作成する
ThrowIfFailed(
pD3D11Device->CreateRenderTargetView(pBackBuffer.Get(), nullptr, &pImpl->m_D3D11RenderTargetView),
L"DX11バックバッファからのレンダリングターゲットビューを作成に失敗しました。",
L"pD3D11Device->CreateRenderTargetView(pBackBuffer.Get(), nullptr, &m_D3D11RenderTargetView)",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
//深度テクスチャの作成
D3D11_TEXTURE2D_DESC descDepth;
ZeroMemory(&descDepth, sizeof(descDepth));
descDepth.Width = App::GetApp()->GetGameWidth();
descDepth.Height = App::GetApp()->GetGameHeight();
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;
ThrowIfFailed(
pD3D11Device->CreateTexture2D(&descDepth, nullptr, &pImpl->m_DepthStencil),
L"DX11深度テクスチャの作成失敗の作成に失敗しました。",
L"pD3D11Device->CreateTexture2D(&descDepth, nullptr, &m_DepthStencil)",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
//深度ステンシルビューの作成
D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
ZeroMemory(&descDSV, sizeof(descDSV));
descDSV.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
descDSV.Texture2D.MipSlice = 0;
ThrowIfFailed(
pD3D11Device->CreateDepthStencilView(pImpl->m_DepthStencil.Get(), &descDSV, &pImpl->m_DepthStencilView),
L"DX11深度ステンシルビューの作成に失敗しました。",
L"pD3D11Device->CreateDepthStencilView(m_DepthStencil.Get(), &descDSV, &m_DepthStencilView)",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
ComPtr<IDXGISurface2> dxgiBackBuffer;
ThrowIfFailed(
pSwapChain->GetBuffer(0, IID_PPV_ARGS(&dxgiBackBuffer)),
L"2dデバイスコンテキスト作成に失敗しました。",
L"m_d2dDevice->CreateDeviceContext()",
L"DeviceResources::Impl::CreateDeviceResources()"
);
ThrowIfFailed(
pD2D11DeviceContext->CreateBitmapFromDxgiSurface(
dxgiBackBuffer.Get(),
nullptr, //デフォルト設定
&pImpl->m_d2dTargetBitmap
),
L"2dビットマップ作成に失敗しました。",
L"pD2D11DeviceContext->CreateBitmapFromDxgiSurface()",
L"DefaultRenderTarget::DefaultRenderTarget()"
);
pD2D11DeviceContext->SetTarget(pImpl->m_d2dTargetBitmap.Get());
//グレースケール テキストのアンチエイリアシング
pD2D11DeviceContext->SetTextAntialiasMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);
}
catch (...){
throw;
}
}
//--------------------------------------------------------------------------------------
// class ShadowMapRenderTarget: public RenderTarget;
// 用途: シャドウマップのレンダリングターゲット
//--------------------------------------------------------------------------------------
//構築と破棄
ShadowMapRenderTarget::ShadowMapRenderTarget(float ShadowMapDimension) :
pImpl(new Impl(ShadowMapDimension))
{
try{
//デバイスとコンテキストインターフェイスの取得
auto Dev = App::GetApp()->GetDeviceResources();
auto pD3D11Device = Dev->GetD3DDevice();
auto pSwapChain = Dev->GetSwapChain();
auto pD3D11DeviceContext = Dev->GetD3DDeviceContext();
//シャドウマップテクスチャの作成
D3D11_TEXTURE2D_DESC shadowMapDesc;
ZeroMemory(&shadowMapDesc, sizeof(D3D11_TEXTURE2D_DESC));
shadowMapDesc.Width = static_cast<UINT>(pImpl->m_ShadowMapDimension);
shadowMapDesc.Height = static_cast<UINT>(pImpl->m_ShadowMapDimension);
shadowMapDesc.MipLevels = 1;
shadowMapDesc.ArraySize = 1;
shadowMapDesc.SampleDesc.Count = 1;
shadowMapDesc.Usage = D3D11_USAGE_DEFAULT;
shadowMapDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
shadowMapDesc.Format = DXGI_FORMAT_R24G8_TYPELESS;
ThrowIfFailed(
pD3D11Device->CreateTexture2D(&shadowMapDesc, nullptr, &pImpl->m_DepthStencil),
L"シャドウマップテクスチャの作成に失敗しました。",
L"pD3D11Device->CreateTexture2D(&shadowMapDesc, nullptr, &m_DepthStencil)",
L"ShadowMapRenderTarget::ShadowMapRenderTarget()"
);
//深度ステンシルビュー作成
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
ThrowIfFailed(
pD3D11Device->CreateDepthStencilView(pImpl->m_DepthStencil.Get(), &depthStencilViewDesc, &pImpl->m_DepthStencilView),
L"深度ステンシルビューの作成に失敗しました。",
L"pD3D11Device->CreateDepthStencilView(&m_DepthStencil, &depthStencilViewDesc, &m_DepthStencilView)",
L"ShadowMapRenderTarget::ShadowMapRenderTarget()"
);
//シェーダーリソースビュー作成
D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
ZeroMemory(&shaderResourceViewDesc, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC));
shaderResourceViewDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shaderResourceViewDesc.Texture2D.MipLevels = 1;
ThrowIfFailed(
pD3D11Device->CreateShaderResourceView(pImpl->m_DepthStencil.Get(), &shaderResourceViewDesc, &pImpl->m_ShaderResourceView),
L"シェーダーリソースビューの作成に失敗しました。",
L"pD3D11Device->CreateShaderResourceView(m_DepthStencil.Get(), &shaderResourceViewDesc, &m_ShaderResourceView)",
L"ShadowMapRenderTarget::ShadowMapRenderTarget()"
);
D3D11_RASTERIZER_DESC shadowRenderStateDesc;
ZeroMemory(&shadowRenderStateDesc, sizeof(D3D11_RASTERIZER_DESC));
shadowRenderStateDesc.CullMode = D3D11_CULL_FRONT;
shadowRenderStateDesc.FillMode = D3D11_FILL_SOLID;
shadowRenderStateDesc.DepthClipEnable = true;
ThrowIfFailed(pD3D11Device->CreateRasterizerState(&shadowRenderStateDesc,&pImpl->m_ShadowRenderState),
L"シャドウマップのラスタライザステートの作成に失敗しました。",
L"pD3D11Device->CreateRasterizerState(&shadowRenderStateDesc,&pImpl->m_ShadowRenderState)",
L"ShadowMapRenderTarget::ShadowMapRenderTarget()"
);
//ビューポートの作成
//シャドウレンダリングビューポート
ZeroMemory(&pImpl->m_ViewPort, sizeof(D3D11_VIEWPORT));
pImpl->m_ViewPort.Height = pImpl->m_ShadowMapDimension;
pImpl->m_ViewPort.Width = pImpl->m_ShadowMapDimension;
pImpl->m_ViewPort.MinDepth = 0.f;
pImpl->m_ViewPort.MaxDepth = 1.f;
}
catch (...){
throw;
}
}
HRESULT Device3D::Initiate(DEVICE_INIT_DATA data)
{
HRESULT hr = S_OK;;
RECT rc;
GetClientRect( data.Hwnd, &rc );
m_iWidth = rc.right - rc.left;;
m_iHeight = rc.bottom - rc.top;
m_hWnd = data.Hwnd;
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_DRIVER_TYPE driverType;
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory( &sd, sizeof(sd) );
sd.BufferCount = 1;
sd.BufferDesc.Width = m_iWidth;
sd.BufferDesc.Height = m_iHeight;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_UNORDERED_ACCESS;
sd.OutputWindow = data.Hwnd;
//sd.SampleDesc.Count = 4;
//sd.SampleDesc.Quality = 8;
sd.SampleDesc = mMultisamplingUsed;
sd.Windowed = TRUE;
D3D_FEATURE_LEVEL featureLevelsToTry[] = {
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
D3D_FEATURE_LEVEL initiatedFeatureLevel;
for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
{
driverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDeviceAndSwapChain(
NULL,
driverType,
NULL,
createDeviceFlags,
featureLevelsToTry,
ARRAYSIZE(featureLevelsToTry),
D3D11_SDK_VERSION,
&sd,
&mSwapChain,
&mDevice,
&initiatedFeatureLevel,
&mDeviceContext);
if( SUCCEEDED( hr ) )
{
/*
char title[256];
sprintf_s(
title,
sizeof(title),
"BTH - Direct3D 11.0 Template | Direct3D 11.0 device initiated with Direct3D %s feature level",
FeatureLevelToString(initiatedFeatureLevel)
);
SetWindowText(mhWnd, title);
*/
break;
}
}
if( FAILED(hr) )
return hr;
if(FAILED(hr = CreateTargetView()))
return hr;
if(FAILED(hr = CreateDepthStencilView()))
return hr;
RestoreTargets();
return hr;
}
// 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;
}
void VirtualDeviceDx11::Resize (int width, int height)
{
if (width == 0 || height == 0)
return ;
DXGI_SWAP_CHAIN_DESC desc;
m_swapChain->GetDesc(&desc);
if (desc.BufferDesc.Width == width &&
desc.BufferDesc.Height == height)
return ;
m_deviceContext->OMSetRenderTargets(0, 0, 0);
// Release all outstanding references to the swap chain's buffers.
m_renderTargetView->Release();
if(m_depthStencilView)
{
m_depthStencilView->Release();
m_depthStencilView = 0;
}
if(m_depthStencilState)
{
m_depthStencilState->Release();
m_depthStencilState = 0;
}
if(m_depthStencilBuffer)
{
m_depthStencilBuffer->Release();
m_depthStencilBuffer = 0;
}
HRESULT hr;
// Preserve the existing buffer count and format.
// Automatically choose the width and height to match the client rect for HWNDs.
hr = m_swapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
// Perform error handling here!
// Get buffer and create a render-target-view.
ID3D11Texture2D* pBuffer;
hr = m_swapChain->GetBuffer(0, __uuidof( ID3D11Texture2D),
(void**) &pBuffer );
// Perform error handling here!
hr = m_device->CreateRenderTargetView(pBuffer, NULL,
&m_renderTargetView);
// Perform error handling here!
pBuffer->Release();
CreateDepthStencilView(width, height);
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView );
// Set up the viewport.
D3D11_VIEWPORT vp;
vp.Width = static_cast<int>(width);
vp.Height = static_cast<int>(height);
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
m_deviceContext->RSSetViewports( 1, &vp );
}
