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);
}
}
bool CDirect3D11::StartUp()
{
if( CreateDeviceAndSwapChain() )
{
//Do nothing
}
else
{
return false;
}
if( CreateRenderTargetView() )
{
//Do nothing
}
else
{
return false;
}
if ( CreateDepthStencilBufferAndView(true) )
{
m_pd3dDeviceContext->OMSetRenderTargets(1, &m_pd3dRenderTargetView, m_pd3dDepthStencilView);
}
else
{
return false;
}
if ( BuildScene() )
{
return true;
}
{
OnDestroy();
return false;
}
}
bool Renderer::OnResize() {
// Render target setting creates references
if(!SetRenderTarget(0,NULL,NULL)) {
return false;
}
// Release views to back buffer
RenderTargetView->Release();
DepthStencilView->Release();
DepthStencilBuffer->Release();
// Then resize
SwapChain->ResizeBuffers(1,0,0,DXGI_FORMAT_UNKNOWN,DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);
// Create view for back buffer we just created
if(!CreateDepthStencilSurface()) {
return false;
}
// Recreate views
if(!CreateRenderTargetView()) {
return false;
}
// Reset render target
if(!SetRenderTarget(1,RenderTargetView,DepthStencilView)) {
return false;
}
return true;
}
void Texture::createRenderTargetViews(ID3D11Texture2D*& pTexture, ID3D11ShaderResourceView*& pTextureView, ID3D11RenderTargetView*& pRenderTargetView)
{
auto pDevice = ORenderer->getDevice();
D3D11_TEXTURE2D_DESC textureDesc = {0};
HRESULT result;
D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
memset(&renderTargetViewDesc, 0, sizeof(renderTargetViewDesc));
memset(&shaderResourceViewDesc, 0, sizeof(shaderResourceViewDesc));
// Setup the render target texture description.
textureDesc.Width = m_size.x;
textureDesc.Height = m_size.y;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE_DEFAULT;
textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;
// Create the render target texture.
result = pDevice->CreateTexture2D(&textureDesc, NULL, &pTexture);
if (result != S_OK)
{
assert(false && "Failed CreateTexture2D");
return;
}
// Setup the description of the render target view.
renderTargetViewDesc.Format = textureDesc.Format;
renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
renderTargetViewDesc.Texture2D.MipSlice = 0;
// Create the render target view.
result = pDevice->CreateRenderTargetView(pTexture, &renderTargetViewDesc, &pRenderTargetView);
if (result != S_OK)
{
assert(false && "Failed CreateRenderTargetView");
return;
}
// Setup the description of the shader resource view.
shaderResourceViewDesc.Format = textureDesc.Format;
shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
shaderResourceViewDesc.Texture2D.MipLevels = 1;
// Create the shader resource view.
result = pDevice->CreateShaderResourceView(pTexture, &shaderResourceViewDesc, &pTextureView);
if (result != S_OK)
{
assert(false && "Failed CreateShaderResourceView");
return;
}
}
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;
}
}
Renderer::Renderer(HWND hwnd) {
this->hwnd = hwnd; // parent window
D3DDevice = NULL;
DeviceContext = NULL;
RenderTargetView = NULL;
SwapChain = NULL;
DepthStencilBuffer = NULL;
DepthStencilView = NULL;
// Initialize and check for DX11 support
if(!CreateDevice()) {
return;
}
// Create swap chain
if(!CreateSwapChain()) {
return;
}
// Create view for back buffer we just created
if(!CreateDepthStencilSurface()) {
return;
}
// Create view for back buffer we just created
if(!CreateRenderTargetView()) { // also creates views for DepthStencil
return;
}
// Use them as targets
if(!SetRenderTarget(1,RenderTargetView,DepthStencilView)) {
return;
}
// Start timer
clock = new Clock(true);
paused = false;
}
LRESULT CALLBACK CGameFramework::OnProcessingWindowMessage(HWND hWnd, UINT nMessageID, WPARAM wParam, LPARAM lParam)
{
switch (nMessageID)
{
/*윈도우의 크기가 변경될 때(현재는 “Alt+Enter“ 전체 화면 모드와 윈도우 모드로 전환될 때) 스왑 체인의 후면버퍼 크기를 조정하고 후면버퍼에 대한 렌더 타겟 뷰를 다시 생성한다. */
case WM_SIZE:
{
m_nWndClientWidth = LOWORD(lParam);
m_nWndClientHeight = HIWORD(lParam);
m_pd3dDeviceContext->OMSetRenderTargets(0, NULL, NULL);
if (m_pd3dRenderTargetView) m_pd3dRenderTargetView->Release();
m_pDXGISwapChain->ResizeBuffers(2, m_nWndClientWidth, m_nWndClientHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0);
CreateRenderTargetView();
CCamera *pCamera = m_pPlayer->GetCamera();
if (pCamera) pCamera->SetViewport(m_pd3dDeviceContext, 0, 0, m_nWndClientWidth, m_nWndClientHeight, 0.0f, 1.0f);
break;
}
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONUP:
case WM_MOUSEMOVE:
OnProcessingMouseMessage(hWnd, nMessageID, wParam, lParam);
break;
case WM_KEYDOWN:
case WM_KEYUP:
OnProcessingKeyboardMessage(hWnd, nMessageID, wParam, lParam);
break;
}
return(0);
}
//--------------------------------------------------------------------------------------
// 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;
}
}
// 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;
}
bool CGameFramework::CreateDirect3DDisplay()
{
RECT rcClient;
::GetClientRect(m_hWnd, &rcClient);
m_nWndClientWidth = rcClient.right - rcClient.left;
m_nWndClientHeight = rcClient.bottom - rcClient.top;
UINT dwCreateDeviceFlags = 0;
#ifdef _DEBUG
dwCreateDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
//디바이스를 생성하기 위하여 시도할 드라이버 유형의 순서를 나타낸다.
D3D_DRIVER_TYPE d3dDriverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE
};
UINT nDriverTypes = sizeof(d3dDriverTypes) / sizeof(D3D10_DRIVER_TYPE);
//디바이스를 생성하기 위하여 시도할 특성 레벨의 순서를 나타낸다.
D3D_FEATURE_LEVEL d3dFeatureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
UINT nFeatureLevels = sizeof(d3dFeatureLevels) / sizeof(D3D_FEATURE_LEVEL);
//생성할 스왑 체인을 서술하는 구조체이다.
DXGI_SWAP_CHAIN_DESC dxgiSwapChainDesc;
::ZeroMemory(&dxgiSwapChainDesc, sizeof(dxgiSwapChainDesc));
dxgiSwapChainDesc.BufferCount = 1;
dxgiSwapChainDesc.BufferDesc.Width = m_nWndClientWidth;
dxgiSwapChainDesc.BufferDesc.Height = m_nWndClientHeight;
dxgiSwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
dxgiSwapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
dxgiSwapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
dxgiSwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
dxgiSwapChainDesc.OutputWindow = m_hWnd;
dxgiSwapChainDesc.SampleDesc.Count = 1;
dxgiSwapChainDesc.SampleDesc.Quality = 0;
dxgiSwapChainDesc.Windowed = TRUE;
D3D_DRIVER_TYPE nd3dDriverType = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL nd3dFeatureLevel = D3D_FEATURE_LEVEL_11_0;
HRESULT hResult = S_OK;
//디바이스의 드라이버 유형과 특성 레벨을 지원하는 디바이스와 스왑 체인을 생성한다. 고수준의 디바이스 생성을 시도하고 실패하면 다음 수준의 디바이스를 생성한다.
for (UINT i = 0; i < nDriverTypes; i++)
{
nd3dDriverType = d3dDriverTypes[i];
if (SUCCEEDED(hResult = D3D11CreateDeviceAndSwapChain(NULL, nd3dDriverType, NULL, dwCreateDeviceFlags, d3dFeatureLevels, nFeatureLevels, D3D11_SDK_VERSION, &dxgiSwapChainDesc, &m_pDXGISwapChain, &m_pd3dDevice, &nd3dFeatureLevel, &m_pd3dDeviceContext))) break;
}
if (!m_pDXGISwapChain || !m_pd3dDevice || !m_pd3dDeviceContext) return(false);
//렌더 타겟 뷰를 생성하는 함수를 호출한다.
if (!CreateRenderTargetView()) return(false);
return(true);
}
