CD3DRenderer::CD3DRenderer(HWND& window)
{
m_hWnd = window;
if(FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&m_pdxgiFactory)))
g_pDebug->printError("Failed to create DXGI Factory.");
IDXGIAdapter1 * pAdapter;
for (UINT i = 0;
m_pdxgiFactory->EnumAdapters1(i, &pAdapter) != DXGI_ERROR_NOT_FOUND;
++i)
m_vAdapters.push_back(pAdapter);
IDXGIOutput *pOutput;
m_vAdapters[m_uiCurrentAdapter]->EnumOutputs(0, &pOutput);
UINT modeCount;
pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &modeCount, nullptr);
DXGI_MODE_DESC *descArr = new DXGI_MODE_DESC[modeCount];
pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &modeCount, descArr);
for (UINT i = 0; i < modeCount; i++)
{
if (descArr[i].RefreshRate.Numerator / descArr[i].RefreshRate.Denominator <= 60)
m_vAdapterModes.push_back(descArr[i]);
}
pOutput->Release();
delete[] descArr;
}
void D3D11Renderer::EnumerateDisplayModes()
{
IDXGIFactory1 *factory = 0;
if (CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&factory) == S_OK)
{
IDXGIAdapter1 *adapter = 0;
for (UINT i = 0; factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++)
{
DXGI_ADAPTER_DESC1 ad;
adapter->GetDesc1(&ad);
char description[128];
size_t n;
wcstombs_s(&n, description, ad.Description, 128);
ATOM_LOG("-------------------------------------------------------------------------------\n");
ATOM_LOG("[info]: adapter[%d]: %s\n", i, description);
ATOM_LOG("[info]: - revision: %d\n", i, ad.Revision);
ATOM_LOG("[info]: - video memory: %d\n", i, ad.DedicatedVideoMemory / 1024 / 1024);
ATOM_LOG("[info]: - system memory: %d\n", i, ad.DedicatedSystemMemory / 1024 / 1024);
ATOM_LOG("[info]: - shared system memory: %d\n", i, ad.SharedSystemMemory / 1024 / 1024);
IDXGIOutput *output = 0;
for (UINT j = 0; adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND; j++)
{
UINT modesCount;
DXGI_FORMAT format = g_settings.format;
output->GetDisplayModeList(format, 0, &modesCount, 0);
DXGI_MODE_DESC *modeDescs = new DXGI_MODE_DESC[modesCount];
output->GetDisplayModeList(format, 0, &modesCount, modeDescs);
ATOM_LOG("[info]: - output %d display modes(%d)\n", j, modesCount);
for (UINT k = 0; k < modesCount; k++)
{
ATOM_LOG("[info]: -- mode[%d]: %d * %d", k, modeDescs[k].Width, modeDescs[k].Height);
ATOM_LOG(", refresh rate: %d/%d\n", modeDescs[i].RefreshRate.Numerator, modeDescs[i].RefreshRate.Denominator);
}
delete[] modeDescs;
memory::SafeRelease(&output);
}
memory::SafeRelease(&adapter);
}
}
memory::SafeRelease(&factory);
}
// 枚举显示模式
/////////////////////////////////////////////////////////////////////////////////
void D3D12Adapter::Enumerate()
{
std::vector<DXGI_FORMAT> formats;
formats.push_back(DXGI_FORMAT_R8G8B8A8_UNORM);
formats.push_back(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB);
formats.push_back(DXGI_FORMAT_B8G8R8A8_UNORM);
formats.push_back(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB);
formats.push_back(DXGI_FORMAT_R10G10B10A2_UNORM);
UINT i = 0;
IDXGIOutput* output = nullptr;
while (adapter_->EnumOutputs(i, &output) != DXGI_ERROR_NOT_FOUND)
{
if (output != nullptr)
{
for (auto const & format : formats)
{
UINT num = 0;
output->GetDisplayModeList(format, DXGI_ENUM_MODES_SCALING, &num, 0);
if (num > 0)
{
std::vector<DXGI_MODE_DESC> mode_descs(num);
output->GetDisplayModeList(format, DXGI_ENUM_MODES_SCALING, &num, &mode_descs[0]);
for (auto const & mode_desc : mode_descs)
{
D3D12VideoMode const video_mode(mode_desc.Width, mode_desc.Height,
mode_desc.Format);
// 如果找到一个新模式, 加入模式列表
if (std::find(modes_.begin(), modes_.end(), video_mode) == modes_.end())
{
modes_.push_back(video_mode);
}
}
}
}
output->Release();
output = nullptr;
}
++ i;
}
std::sort(modes_.begin(), modes_.end());
}
DXGI_RATIONAL D3D11Renderer::GetDefaultRefreshRate()
{
DXGI_RATIONAL refreshRate = {59, 1};
IDXGIFactory1 *factory = 0;
if (CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **)&factory) == S_OK)
{
IDXGIAdapter1 *adapter = 0;
for (UINT i = 0; factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++)
{
DXGI_ADAPTER_DESC1 ad;
IDXGIOutput *output = 0;
adapter->GetDesc1(&ad);
for (UINT j = 0; adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND; j++)
{
UINT modesCount;
DXGI_FORMAT format = g_settings.format;
output->GetDisplayModeList(format, 0, &modesCount, 0);
DXGI_MODE_DESC *modeDescs = new DXGI_MODE_DESC[modesCount];
output->GetDisplayModeList(format, 0, &modesCount, modeDescs);
for (UINT k = 0; k < modesCount; k++)
{
if (modeDescs[k].Width == (UINT)g_settings.width &&
modeDescs[k].Height == (UINT)g_settings.height)
{
refreshRate = modeDescs[i].RefreshRate;
delete[] modeDescs;
memory::SafeRelease(&output);
memory::SafeRelease(&adapter);
memory::SafeRelease(&factory);
return refreshRate;
}
}
delete[] modeDescs;
memory::SafeRelease(&output);
}
memory::SafeRelease(&adapter);
}
}
memory::SafeRelease(&factory);
return refreshRate;
}
bool DX11::CreateDevice(HWND a_hwnd)
{
HRESULT result;
// Create a DirectX graphics interface factory.
IDXGIFactory* factory;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**) &factory);
if (FAILED(result))
{
LOG_ERROR("Could not create DXGI Factory.");
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
IDXGIAdapter* adapter;
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
LOG_ERROR("Could not create graphics adapter.");
return false;
}
// Enumerate the primary adapter output (monitor).
IDXGIOutput* adapterOutput;
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
LOG_ERROR("Could not create graphics adapter output.");
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
unsigned int displaymodes;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &displaymodes, NULL);
if (FAILED(result))
{
LOG_ERROR("Could not create display mode list.");
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[displaymodes];
if (!displayModeList)
{
LOG_ERROR("Could not fill display mode list.");
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &displaymodes, displayModeList);
if (FAILED(result))
{
LOG_ERROR("Could not fill display mode list structures.");
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
unsigned int numerator;
unsigned int denominator;
for (unsigned int i = 0; i < displaymodes; i++)
{
if (displayModeList[i].Width == (unsigned int) m_width)
{
if (displayModeList[i].Height == (unsigned int) m_height)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
LOG_ERROR("Could not get graphics device description.");
return false;
}
// Store the dedicated video card memory in megabytes.
m_vmemory = (int) (adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
unsigned int stringLength;
int error = wcstombs_s(&stringLength, m_cardDesc, 128, adapterDesc.Description, 128);
if (error != 0)
{
LOG_ERROR("Could not get graphics device name.");
return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release resources.
RELEASE(adapterOutput);
RELEASE(adapter);
RELEASE(factory);
// Initialize the swap chain description.
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = (UINT) (m_width * m_renderScale);
swapChainDesc.BufferDesc.Height = (UINT) (m_height * m_renderScale);
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if (m_vsync)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = a_hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
swapChainDesc.Windowed = (m_fullscreen) ? false : true;
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Create the swap chain, Direct3D device, and Direct3D device context.
#if defined(_DEBUG)
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG | D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS, NULL, NULL,
D3D11_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pDevice, NULL, &m_pDeviceContext);
#else
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, NULL, NULL,
D3D11_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pDevice, NULL, &m_pDeviceContext);
#endif
if (FAILED(result))
{
LOG_ERROR("Could not create D3D11 device, device context and swap chain.");
return false;
}
// Get the pointer to the back buffer.
result = m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*) &m_pBackBuffer);
if (FAILED(result))
{
LOG_ERROR("Could not get back buffer.");
return false;
}
#if defined(_DEBUG)
result = m_pDevice->QueryInterface(__uuidof(ID3D11Debug), (LPVOID*) &m_pDebug);
if (FAILED(result))
{
LOG_ERROR("Could not create debug interface.");
return false;
}
#endif
return true;
}
void EnableDrawing (HGLRC *hRC) {
WindowResizedCallback = &WindowResized;
d3dmgr = new ContextManager();
int screenWidth = window_get_width(),
screenHeight = window_get_height();
screenWidth = screenWidth <= 0 ? 1 : screenWidth;
screenHeight = screenHeight <= 0 ? 1 : screenHeight;
bool vsync = false;
HWND hwnd = enigma::hWnd;
bool fullscreen = false;
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
// Store the vsync setting.
m_vsync_enabled = vsync;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
{
//return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
{
//return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
{
//return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
{
//return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
//return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
{
//return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
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;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
{
//return false;
}
// Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
//error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
//return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if(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 of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if(FAILED(result))
{
//return false;
}
// Get the pointer to the back buffer.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
{
//return false;
}
// Create the render target view with the back buffer pointer.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
{
//return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
//return false;
}
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
// Create the depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
{
//return false;
}
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// Initailze the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
//return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
{
//return false;
}
// Now set the rasterizer state.
m_deviceContext->RSSetState(m_rasterState);
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
}
bool InitDirect3D(RENDERER_SETTINGS * pSetup)
{
DXGI_FORMAT format = DXGI_FORMAT_R8G8B8A8_UNORM;
DXGI_SWAP_CHAIN_DESC desc;
ZeroMemory(&desc, sizeof(DXGI_SWAP_CHAIN_DESC));
desc.BufferCount = 1;
desc.BufferDesc.Width = pSetup->nWidth;
desc.BufferDesc.Height = pSetup->nHeight;
desc.BufferDesc.Format = format;
if (pSetup->bVsync)
{
bVsync = true;
IDXGIFactory1 * pFactory = NULL;
HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory);
if (pFactory)
{
IDXGIAdapter1 * pAdapter = NULL;
pFactory->EnumAdapters1( 0, &pAdapter );
if (pAdapter)
{
IDXGIOutput * pOutput = NULL;
pAdapter->EnumOutputs( 0, &pOutput );
if (pOutput)
{
unsigned int nModeCount = 0;
pOutput->GetDisplayModeList( format, DXGI_ENUM_MODES_INTERLACED | DXGI_ENUM_MODES_SCALING, &nModeCount, NULL);
DXGI_MODE_DESC * pModes = new DXGI_MODE_DESC[ nModeCount ];
pOutput->GetDisplayModeList( format, DXGI_ENUM_MODES_INTERLACED | DXGI_ENUM_MODES_SCALING, &nModeCount, pModes);
for (int i=0; i<nModeCount; i++)
{
if (pModes[i].Width == pSetup->nWidth && pModes[i].Height == pSetup->nHeight)
{
desc.BufferDesc = pModes[i];
break;
}
}
delete[] pModes;
pOutput->Release();
}
pAdapter->Release();
}
pFactory->Release();
}
}
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.OutputWindow = hWnd;
desc.SampleDesc.Count = 1;
desc.Windowed = pSetup->windowMode != RENDERER_WINDOWMODE_FULLSCREEN;
DWORD deviceCreationFlags = 0;
#ifdef _DEBUG
//deviceCreationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
if (D3D11CreateDeviceAndSwapChain(
NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
deviceCreationFlags,
NULL,
NULL,
D3D11_SDK_VERSION,
&desc,
&pSwapChain,
&pDevice,
NULL,
&pContext) != S_OK)
{
printf("[Renderer] D3D11CreateDeviceAndSwapChain failed\n");
return false;
}
pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer);
pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRenderTarget);
pBackBuffer->Release();
pContext->OMSetRenderTargets(1, &pRenderTarget, NULL);
// create staging texture for frame grabbing
D3D11_TEXTURE2D_DESC description;
pBackBuffer->GetDesc( &description );
description.BindFlags = 0;
description.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
description.Usage = D3D11_USAGE_STAGING;
HRESULT hr = pDevice->CreateTexture2D( &description, NULL, &pFrameGrabTexture );
return true;
}
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen,
float screenDepth, float screenNear)
{
HRESULT result = E_FAIL;
// create DirectX graphics interface factory (need to generating other DXGI objects)
IDXGIFactory* factory = nullptr;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
return false;
// create adapter
IDXGIAdapter* adapter = nullptr;
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
return false;
// enumerate outputs
IDXGIOutput* adapterOutput = nullptr;
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
return false;
// get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format
unsigned numModes = 0;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED,
&numModes, NULL);
if (FAILED(result))
return false;
// create a list to hold all possible display modes
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
return false;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED,
&numModes, displayModeList);
if (FAILED(result))
return false;
// go through all displays modes and find the one, that matches the screen width and height
unsigned numerator = 0, denominator = 0;
for (int i = 0; i < numModes; ++i)
{
if (displayModeList[i].Width == (unsigned)screenWidth)
{
if (displayModeList[i].Height == (unsigned)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// get the adapter description
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
return false;
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // store in megabytes
// convert the name of videocard to a character array and store it
unsigned stringLength = 0;
int error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error)
return false;
// write video card data in text file
std::ofstream videocardFile;
videocardFile.open("VideoCardInfo.txt");
videocardFile << "Video Card: " << m_videoCardDescription << std::endl
<< "Video Card Memory: " << m_videoCardMemory << "Mb" << std::endl;
videocardFile.close();
// release the structures and interfaces used to get information
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
// initialize the swap chain description
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
// create the swap chain, Direct3D device and Direct3D device context
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel,
1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
return false;
// get the pointer to the back buffer
ID3D11Texture2D* backBufferPtr = nullptr;
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
return false;
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result))
return false;
backBufferPtr->Release();
backBufferPtr = nullptr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
return false;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
return false;
// set the depth stencil state
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// initialize the depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
return false;
// bind the render target view and depth stencil buffer to the output render pipeline
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// setup the raster description which will determine how and what polygons will be drawn
D3D11_RASTERIZER_DESC rasterDesc;
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result))
return false;
m_deviceContext->RSSetState(m_rasterState);
// setup the viewport for rendering
D3D11_VIEWPORT viewport;
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
m_deviceContext->RSSetViewports(1, &viewport);
// setup the projection matrix
float fieldOfView = (float)D3DX_PI / 4.0f;
float screenAspect = (float)screenWidth / (float)screenHeight;
// create the projection matrix for 3D rendering
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// initialize the world matrix
D3DXMatrixIdentity(&m_worldMatrix);
// create an orthographic matrix for 2D rendering
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
HRESULT DXTInitDevice(const DXTRenderParams& params, const DXTWindow* window, IDXGISwapChain** swapChainOut,
ID3D11Device** deviceOut, ID3D11DeviceContext** deviceContextOut)
{
IDXGIFactory* factory;
HRESULT result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
IDXGIAdapter* adapter;
result = factory->EnumAdapters(0, &adapter);
IDXGIOutput* adapterOutput;
result = adapter->EnumOutputs(0, &adapterOutput);
UINT modeCount;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &modeCount, nullptr);
DXGI_MODE_DESC* modeDescriptions = new DXGI_MODE_DESC[modeCount];
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &modeCount, modeDescriptions);
DXGI_MODE_DESC* descMatch = nullptr;
for (UINT i = 0; i < modeCount; ++i)
{
DXGI_MODE_DESC* desc = &modeDescriptions[i];
if (desc->Width == params.Extent.Width && desc->Height == params.Extent.Height)
{
OutputDebugString("Found compatible display mode!\n");
descMatch = desc;
break;
}
}
if (descMatch == nullptr)
{
OutputDebugString("No DXGI mode match found - using a default!\n");
descMatch = modeDescriptions;
}
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
adapterOutput->Release();
adapter->Release();
factory->Release();
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.Windowed = params.Windowed;
swapChainDesc.BufferCount = 2;
swapChainDesc.BufferDesc = *descMatch;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = window->GetWindowHandle();
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
delete[] modeDescriptions;
UINT deviceCreationFlags = 0;
#ifdef ENABLE_DIRECT3D_DEBUG
deviceCreationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
if (!params.Windowed)
swapChainDesc.Flags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
OutputDebugString("Creating device and swap chain...\n");
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
deviceCreationFlags, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc,
swapChainOut, deviceOut, nullptr, deviceContextOut);
if (FAILED(result))
{
OutputDebugString("Failed to create device and swap chain!\n");
return E_FAIL;
}
OutputDebugString("Device and swap chain created successfully!\n");
return S_OK;
}
bool InitFactory()
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for (i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == WIN_WIDTH)
{
if (displayModeList[i].Height == WIN_HEIGHT)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
char m_videoCardDescription[128];
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
delete[] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
return true;
}
bool CDirectEngine::CollectAdapters(Vector2<unsigned int> aWindowSize, Vector2<int>& aNumDenumerator, IDXGIAdapter*& outAdapter)
{
HRESULT result = S_OK;
IDXGIFactory* factory;
DXGI_MODE_DESC* displayModeList = nullptr;
unsigned int numModes = 0;
unsigned int i = 0;
unsigned int denominator = 0;
unsigned int numerator = 0;
result = CreateDXGIFactory( __uuidof( IDXGIFactory ), (void**)&factory );
if( FAILED( result ) )
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
IDXGIAdapter* usingAdapter = nullptr;
int adapterIndex = 0;
std::vector<DXGI_ADAPTER_DESC> myAdapterDescs;
std::vector<IDXGIAdapter*> myAdapters;
while (factory->EnumAdapters(adapterIndex, &usingAdapter) != DXGI_ERROR_NOT_FOUND)
{
DXGI_ADAPTER_DESC adapterDesc;
usingAdapter->GetDesc(&adapterDesc);
myAdapterDescs.push_back( adapterDesc );
myAdapters.push_back(usingAdapter);
++adapterIndex;
}
if( adapterIndex == 0 )
{
return false;
}
INFO_PRINT( "%s", "Video card(s) detected: " );
for( DXGI_ADAPTER_DESC desc : myAdapterDescs )
{
int memory = (int)(desc.DedicatedVideoMemory / 1024 / 1024);
INFO_PRINT(" %ls%s%i%s", desc.Description, " Mem: ", memory, "Mb");
}
DXGI_ADAPTER_DESC usingAdapterDesc = myAdapterDescs[0];
usingAdapter = myAdapters[0];
INFO_PRINT("%s", "Detecting best card...");
const std::wstring nvidia = L"NVIDIA";
const std::wstring ati = L"ATI";
int memory = (int)(usingAdapterDesc.DedicatedVideoMemory / 1024 / 1024);
int mostMem = 0;
for (unsigned int i = 0; i < myAdapterDescs.size(); i++)
{
DXGI_ADAPTER_DESC desc = myAdapterDescs[i];
memory = (int)(desc.DedicatedVideoMemory / 1024 / 1024);
std::wstring name = desc.Description;
if (name.find(nvidia) != std::wstring::npos || name.find(ati) != std::wstring::npos)
{
if (memory > mostMem)
{
mostMem = memory;
usingAdapterDesc = desc;
usingAdapter = myAdapters[i];
}
}
}
INFO_PRINT("%s%ls%s%i", "Using graphic card: ", usingAdapterDesc.Description, " Dedicated Mem: ", mostMem);
// Enumerate the primary adapter output (monitor).
IDXGIOutput* pOutput = nullptr;
if (usingAdapter->EnumOutputs(0, &pOutput) != DXGI_ERROR_NOT_FOUND)
{
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (!FAILED(result))
{
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if (displayModeList)
{
// Now fill the display mode list structures.
result = pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (!FAILED(result))
{
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for (i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)aWindowSize.x)
{
if (displayModeList[i].Height == (unsigned int)aWindowSize.y)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
}
}
}
// Release the adapter output.
pOutput->Release();
pOutput = 0;
}
// Get the adapter (video card) description.
result = usingAdapter->GetDesc(&usingAdapterDesc);
if( FAILED( result ) )
{
return false;
}
// Store the dedicated video card memory in megabytes.
myVideoCardMemory = (int)(usingAdapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Release the display mode list.
delete[] displayModeList;
displayModeList = 0;
// Release the factory.
factory->Release();
factory = 0;
if( myEnableVSync == true )
{
aNumDenumerator.x = numerator;
aNumDenumerator.y = denominator;
}
else
{
aNumDenumerator.x = 0;
aNumDenumerator.y = 1;
}
outAdapter = usingAdapter;
return true;
}
bool graphicD3d::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
HRESULT hr;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
UINT nummodes, numerator, denominator;
DXGI_MODE_DESC* displayModelist;
DXGI_ADAPTER_DESC adapterDesc;
DXGI_SWAP_CHAIN_DESC swapchainDesc;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
// 수직동기화 설정 ( true / false )
m_vsync = vsync;
//DirectX Graphic Infrastructure 인터페이스 팩토리 만들기.
hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(hr))
return false;
//첫번째 그래픽 카드 어댑터 만들기.
hr = factory->EnumAdapters(0, &adapter);
if (FAILED(hr))
return false;
//첫번째 모니터의 어댑터 만들기.
hr = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(hr))
return false;
//DXGI_FORMAT_R8G8B8A8_UNORM 모니터 출력 포멧에 맞는 모드의 개수 구하기.
hr = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &nummodes, NULL);
if (FAILED(hr))
return false;
//사용 가능한 모든 모니터와 그래픽카드 조합을 저장할 리스트 생성.
displayModelist = new DXGI_MODE_DESC[nummodes];
if (!displayModelist)
return false;
//displayModelist 에 값들 채워넣기.
hr = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &nummodes, displayModelist);
if (FAILED(hr))
return false;
//그래픽 카드와 모니터의 화면 너비/높이 조합을 찾기 완료.
//모니터의 refresh rate 의 분모 와 분자 값을 저장.
for (int i = 0; i < nummodes; i++)
{
if (displayModelist[i].Width == (UINT)screenWidth &&
displayModelist[i].Height == (UINT)screenHeight)
{
numerator = displayModelist[i].RefreshRate.Numerator;
denominator = displayModelist[i].RefreshRate.Denominator;
}
}
/*
*/
//그래픽 카드 정보 가져오기.
hr = adapter->GetDesc(&adapterDesc);
if (FAILED(hr))
return false;
//그래픽 카드 메모리 크기 가져오기. ( MegaBytes )
m_videoMemory = UINT(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//그래픽 카드 이름 가져오기.
lstrcpynW(m_videoDescription, adapterDesc.Description, 128);
/*
*/
// 원하는 정보 조회 끝나면, 해당 리소스들 해제
delete [] displayModelist;
displayModelist = nullptr;
//모니터 출력 어댑터 해제
adapterOutput->Release();
adapterOutput = nullptr;
//그래픽카드 어댑터 해제
adapter->Release();
adapter = nullptr;
//팩토리 해제
factory->Release();
factory = nullptr;
/*
스왑체인 설정
*/
ZeroMemory( &swapchainDesc, sizeof( swapchainDesc ) );
//백버퍼 개수를 1개로 설정.
swapchainDesc.BufferCount = 1;
swapchainDesc.BufferDesc.Width = screenWidth;
swapchainDesc.BufferDesc.Height = screenHeight;
swapchainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (m_vsync) {
//vsync 수치에 맞춰서 page flip 이 일어난다.
swapchainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapchainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else {
//vsync 와 상관없이 최대한 많이 그리게 한다.
swapchainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapchainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// 백버퍼를 렌더 타겟 용도로 사용 설정.
swapchainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapchainDesc.OutputWindow = hwnd;
//멀티샘플링 설정을 안함.
swapchainDesc.SampleDesc.Count = 1;
swapchainDesc.SampleDesc.Quality = 0;
//전체화면 모드 창 모드 설정.
if (fullscreen) {
swapchainDesc.Windowed = FALSE;
}
else {
swapchainDesc.Windowed = TRUE;
}
//스캔라인 정렬 및 사용여부를 안함 (unspecified) 으로 설정.
swapchainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapchainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//출력 후 백버퍼 내용 버림으로 설정.
swapchainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//추가 옵션 플랙 사용 안함.
swapchainDesc.Flags = 0;
/*
디바이스 설정
*/
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
//그래픽 카드가 dx11 지원되면 HARDWARE,
//실패하면 REFERENCE 로 처리된다. ( 속도는 HARDWARE 대비 1/1000 정도 느림 )
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE( driverTypes );
//directx 버젼 설정
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
UINT numFeatureLevels = ARRAYSIZE( featureLevels );
for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
{
m_driverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDeviceAndSwapChain( NULL, m_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &swapchainDesc, &m_swapChain, &m_device, &m_featureLevel, &m_deviceContext );
if( SUCCEEDED( hr ) )
break;
}
if( FAILED( hr ) )
return false;
/*
렌더타겟뷰 (render target view) 만들기
*/
//백버퍼 포인터를 가져오기.
ID3D11Texture2D* pBackBuffer = NULL;
hr = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
if( FAILED( hr ) )
return false;
//백버퍼 포인터로 렌더타겟뷰 생성.
hr = m_device->CreateRenderTargetView( pBackBuffer, NULL, &m_renderTargetView );
if( FAILED( hr ) )
return false;
//렌더타겟 생성되면 백버퍼 포인터 필요없으므로 제거.
pBackBuffer->Release();
pBackBuffer = nullptr;
/*
깊이버퍼 (depth buffer) 만들기 (옵션)
*/
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
//깊이버퍼 2D텍스쳐 생성
hr = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilbuffer);
if (FAILED(hr))
return false;
/*
깊이 스텐실 정의 (옵션)
*/
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
//픽셀 전면부 스텐실 연산 처리
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;
//픽셀 후면부 스텐실 연산 처리
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;
//깊이 스텐실 상태 생성
hr = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(hr))
return false;
//디바이스 컨텍스트에 깊이 스텐실 상태 적용.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
/*
깊이 스텐실 뷰 만들기
*/
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// 깊이-스텐실 뷰를 생성.
hr = m_device->CreateDepthStencilView(m_depthStencilbuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(hr))
return false;
/*
디바이스 컨텍스트에 렌더타겟뷰 와 깊이스텐실뷰를 적용.
*/
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
/*
래스터라이징 설정 (옵션)
- 도형을 어떻게 그릴지 결정 ( 와이어프레임, 2 side 렌더링 등등.. )
*/
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
//디바이스로 래스터라이징 상태 생성.
hr = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(hr))
return false;
//디바이스 컨텍스트로 래스터라이징 상태 적용.
m_deviceContext->RSSetState(m_rasterState);
/*
뷰포트 생성
*/
viewport.Width = (FLOAT)screenWidth;
viewport.Height = (FLOAT)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
m_deviceContext->RSSetViewports( 1, &viewport );
/*
투영 행렬 ( projection matrix ) 생성
- 3d 화면을 2d 뷰포트 공간으로 변환
- 복사본으로 셰이더에서 사용 할 수 있게 한다.
*/
float fieldOfView = (float)XM_PI / 4.0f;
float screenAspect = (float)screenWidth / (float)screenHeight;
m_projectionMatrix = XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenDepth);
/*
월드 행렬 ( world matrix ) 생성
- 오브젝트들을 3d 좌표로 변환하기 위한 행렬
- 이동 / 회전 / 크기 에 사용.
- 복사본으로 셰이더에 사용 할 수 있게 한다.
*/
// 월드 행렬을 단위 행렬로 초기화
m_worldMatrix = XMMatrixIdentity();
/*
뷰 행렬 ( view matrix )
- 카메라에서 따로 생성하기 위해 일단 생략.
*/
/*
정사영 행렬 ( Orthographic matix 생성 )
- 원근감이 없는 행렬
- 2d 이미지나 UI 등을 표현할 때 사용.
*/
// 2D 렌더링에 사용될 정사영 행렬을 생성.
m_orthoMatrix = XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
static int
WINRT_AddDisplaysForOutput (_THIS, IDXGIAdapter1 * dxgiAdapter1, int outputIndex)
{
HRESULT hr;
IDXGIOutput * dxgiOutput = NULL;
DXGI_OUTPUT_DESC dxgiOutputDesc;
SDL_VideoDisplay display;
char * displayName = NULL;
UINT numModes;
DXGI_MODE_DESC * dxgiModes = NULL;
int functionResult = -1; /* -1 for failure, 0 for success */
DXGI_MODE_DESC modeToMatch, closestMatch;
SDL_zero(display);
hr = dxgiAdapter1->EnumOutputs(outputIndex, &dxgiOutput);
if (FAILED(hr)) {
if (hr != DXGI_ERROR_NOT_FOUND) {
WIN_SetErrorFromHRESULT(__FUNCTION__ ", IDXGIAdapter1::EnumOutputs failed", hr);
}
goto done;
}
hr = dxgiOutput->GetDesc(&dxgiOutputDesc);
if (FAILED(hr)) {
WIN_SetErrorFromHRESULT(__FUNCTION__ ", IDXGIOutput::GetDesc failed", hr);
goto done;
}
SDL_zero(modeToMatch);
modeToMatch.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
modeToMatch.Width = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left);
modeToMatch.Height = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top);
hr = dxgiOutput->FindClosestMatchingMode(&modeToMatch, &closestMatch, NULL);
if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE) {
/* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE gets returned by IDXGIOutput::FindClosestMatchingMode
when running under the Windows Simulator, which uses Remote Desktop (formerly known as Terminal
Services) under the hood. According to the MSDN docs for the similar function,
IDXGIOutput::GetDisplayModeList, DXGI_ERROR_NOT_CURRENTLY_AVAILABLE is returned if and
when an app is run under a Terminal Services session, hence the assumption.
In this case, just add an SDL display mode, with approximated values.
*/
SDL_DisplayMode mode;
SDL_zero(mode);
display.name = "Windows Simulator / Terminal Services Display";
mode.w = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left);
mode.h = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top);
mode.format = DXGI_FORMAT_B8G8R8A8_UNORM;
mode.refresh_rate = 0; /* Display mode is unknown, so just fill in zero, as specified by SDL's header files */
display.desktop_mode = mode;
display.current_mode = mode;
if ( ! SDL_AddDisplayMode(&display, &mode)) {
goto done;
}
} else if (FAILED(hr)) {
WIN_SetErrorFromHRESULT(__FUNCTION__ ", IDXGIOutput::FindClosestMatchingMode failed", hr);
goto done;
} else {
displayName = WIN_StringToUTF8(dxgiOutputDesc.DeviceName);
display.name = displayName;
WINRT_DXGIModeToSDLDisplayMode(&closestMatch, &display.desktop_mode);
display.current_mode = display.desktop_mode;
hr = dxgiOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, 0, &numModes, NULL);
if (FAILED(hr)) {
if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE) {
// TODO, WinRT: make sure display mode(s) are added when using Terminal Services / Windows Simulator
}
WIN_SetErrorFromHRESULT(__FUNCTION__ ", IDXGIOutput::GetDisplayModeList [get mode list size] failed", hr);
goto done;
}
dxgiModes = (DXGI_MODE_DESC *)SDL_calloc(numModes, sizeof(DXGI_MODE_DESC));
if ( ! dxgiModes) {
SDL_OutOfMemory();
goto done;
}
hr = dxgiOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, 0, &numModes, dxgiModes);
if (FAILED(hr)) {
WIN_SetErrorFromHRESULT(__FUNCTION__ ", IDXGIOutput::GetDisplayModeList [get mode contents] failed", hr);
goto done;
}
for (UINT i = 0; i < numModes; ++i) {
SDL_DisplayMode sdlMode;
WINRT_DXGIModeToSDLDisplayMode(&dxgiModes[i], &sdlMode);
SDL_AddDisplayMode(&display, &sdlMode);
}
}
if (SDL_AddVideoDisplay(&display) < 0) {
goto done;
}
functionResult = 0; /* 0 for Success! */
done:
if (dxgiModes) {
SDL_free(dxgiModes);
}
if (dxgiOutput) {
dxgiOutput->Release();
}
if (displayName) {
SDL_free(displayName);
}
return functionResult;
}
bool D3D::InitializeD3D(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen)
{
HRESULT result; //used to test things are created ok.
vsync;
//----------------------------------------------------------------------------------------------
// Fetch the numerator and denominator for refresh rate and video card description.
// Create DirectX Graphics Interface factory.
IDXGIFactory* factory;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
return false;
// Create adapter.
IDXGIAdapter* adapter;
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
return false;
// Enumerate primary adapter output (monitor).
IDXGIOutput* adapterOutput;
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
return false;
// Get the number of modes that fit the DXGI_R8G8B8A8_UNORM display format for adpater output.
unsigned int numModes;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
return false;
// Create a list to hold all possible display modes.
DXGI_MODE_DESC* displayModeList;
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
return false;
// Fill list.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
return false;
// Loop through modes and find one that matches screen width and height, store numerator and
// denominator for corresponding refresh rate.
unsigned int numerator, denominator;
for(unsigned int i = 0; i < numModes; ++i)
{
if(displayModeList[i].Width == (unsigned int)screenWidth &&
displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
// Get adapter description.
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
return false;
// Store dedicated video card memory (in mb).
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to char array and store.
unsigned int stringLength;
int error = wcstombs_s(&stringLength, m_videoCardDesc, 128, adapterDesc.Description, 128);
if(error != 0)
return false;
// Release unneeded memory.
delete[] displayModeList;
displayModeList = 0;
adapterOutput->Release();
adapterOutput = 0;
adapter->Release();
adapter = 0;
factory->Release();
factory = 0;
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Set up SwapChain description and create swap chain.
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Setup back buffer.
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Refresh Rate.
if(m_vsyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{ // Draw as soon as possible.
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
// Turn off multisampling.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.Windowed = !fullscreen;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
// Create the swap chain.
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel,
1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL,
&m_deviceContext);
if(FAILED(result))
return false;
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Set up render target view.
ID3D11Texture2D* backBufferPtr;
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
return false;
// Create render target view with back buffer ptr.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
return false;
backBufferPtr->Release();
backBufferPtr = 0;
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Set up depthStencilBuffer.
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up description.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create depth/stencil buffer.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
return false;
// Setup depth stencil description.
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
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;
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;
// Create depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
return false;
// Set depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Create second depth stencil state with depth disabled. (for 2D rendering)
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc,
&m_depthDisabledStencilState);
if(FAILED(result))
return false;
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Create description of the view of the depth stencil buffer.
// Do this so D3D knows to use the depth buffer as a depth stencil texture.
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc,
&m_depthStencilView);
if(FAILED(result))
return false;
// Bind render target view and depth stencil buffer to output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Create rasterizer state and viewport.
D3D11_RASTERIZER_DESC rasterDesc;
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0;
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
return false;
m_deviceContext->RSSetState(m_rasterState);
// Create rasterizer state with wireframe fill mode.
D3D11_RASTERIZER_DESC rasterWireframeDesc;
rasterWireframeDesc.AntialiasedLineEnable = false;
rasterWireframeDesc.CullMode = D3D11_CULL_BACK;
rasterWireframeDesc.DepthBias = 0;
rasterWireframeDesc.DepthBiasClamp = 0.0f;
rasterWireframeDesc.DepthClipEnable = true;
rasterWireframeDesc.FillMode = D3D11_FILL_WIREFRAME;
rasterWireframeDesc.FrontCounterClockwise = false;
rasterWireframeDesc.MultisampleEnable = false;
rasterWireframeDesc.ScissorEnable = false;
rasterWireframeDesc.SlopeScaledDepthBias = 0.0;
result = m_device->CreateRasterizerState(&rasterWireframeDesc, &m_rasterStateWireframe);
if(FAILED(result))
return false;
// Set up viewport.
D3D11_VIEWPORT viewport;
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
m_deviceContext->RSSetViewports(1, &viewport);
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Create blend states.
D3D11_BLEND_DESC blendStateDesc;
ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC));
blendStateDesc.RenderTarget[0].BlendEnable = TRUE;
blendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
result = m_device->CreateBlendState(&blendStateDesc, &m_alphaEnableBlendingState);
if(FAILED(result))
{
return false;
}
blendStateDesc.RenderTarget[0].BlendEnable = FALSE;
result = m_device->CreateBlendState(&blendStateDesc, &m_alphaDisableBlendingState);
if(FAILED(result))
{
return false;
}
//----------------------------------------------------------------------------------------------
return true;
}
char* app_display_querymodes()
{
IDXGIFactory* factory;
if (FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory)))
return NULL;
IDXGIAdapter* adapter;
uint adapter_id = 0;
DXGI_ADAPTER_DESC desc;
char gpu_desc[128];
size_t outsz;
/* start json data (adapter array) */
json_t jroot = json_create_arr();
/* read adapters */
while (factory->EnumAdapters(adapter_id, &adapter) != DXGI_ERROR_NOT_FOUND) {
adapter->GetDesc(&desc);
str_widetomb(gpu_desc, desc.Description, sizeof(gpu_desc));
json_t jadapter = json_create_obj();
json_additem_toarr(jroot, jadapter);
json_additem_toobj(jadapter, "name", json_create_str(gpu_desc));
json_additem_toobj(jadapter, "id", json_create_num((fl64)adapter_id));
/* enumerate monitors */
json_t joutputs = json_create_arr();
json_additem_toobj(jadapter, "outputs", joutputs);
IDXGIOutput* output;
uint output_id = 0;
while (adapter->EnumOutputs(output_id, &output) != DXGI_ERROR_NOT_FOUND) {
json_t joutput = json_create_obj();
json_additem_toarr(joutputs, joutput);
json_additem_toobj(joutput, "id", json_create_num((fl64)output_id));
/* enumerate modes */
json_t jmodes = json_create_arr();
json_additem_toobj(joutput, "monitors", jmodes);
uint mode_cnt;
HRESULT hr = output->GetDisplayModeList(DEFAULT_DISPLAY_FORMAT, 0, &mode_cnt, NULL);
if (SUCCEEDED(hr)) {
DXGI_MODE_DESC* modes = (DXGI_MODE_DESC*)ALLOC(sizeof(DXGI_MODE_DESC) * mode_cnt, 0);
ASSERT(modes);
output->GetDisplayModeList(DEFAULT_DISPLAY_FORMAT, 0, &mode_cnt, modes);
for (uint i = 0; i < mode_cnt; i++) {
if (modes[i].RefreshRate.Denominator != 1)
continue;
json_t jmode = json_create_obj();
json_additem_toobj(jmode, "width", json_create_num((fl64)modes[i].Width));
json_additem_toobj(jmode, "height", json_create_num((fl64)modes[i].Height));
json_additem_toobj(jmode, "refresh-rate",
json_create_num((fl64)modes[i].RefreshRate.Numerator));
json_additem_toarr(jmodes, jmode);
}
FREE(modes);
}
output_id ++;
}
adapter->Release();
adapter_id ++;
}
factory->Release();
char* r = json_savetobuffer(jroot, &outsz, FALSE);
json_destroy(jroot);
return r;
}
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen,
float screenDepth, float screenNear)
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
// 保存垂直同步设置
m_vsync_enabled = vsync;
// 创建一个DirectX graphics 接口工厂
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
return false;
// 用接口工厂创建一个主显卡的适配
result =factory->EnumAdapters(0, &adapter);
if(FAILED(result))
return false;
// 得到主适配器的输出
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
return false;
//得到适合 DXGI_FORMAT_R8G8B8A8_UNORM 的显示模式
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr);
if(FAILED(result))
return false;
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
return false;
// 保存显示模式到displayModeList中
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
return false;
// 遍历所有显示模式，得到刷新率两个参数值numerator 和 denominator
for (int i = 0; i < numModes; i++)
{
if(displayModeList[i].Width == screenWidth)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
// 得到显卡描述
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
return false;
// 保存显存大小
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//保存显卡描述串
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
return false;
// 释放显示模式列表
delete[] displayModeList;
displayModeList = nullptr;
//释放适配器输出
adapterOutput->Release();
adapterOutput = nullptr;
//释放适配器
adapter->Release();
adapter = nullptr;
//释放接口工厂
factory->Release();
factory = nullptr;
//初始化交换链描述
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// 用1个后缓冲
swapChainDesc.BufferCount = 1;
// 帧缓冲的大小和应用程序窗口大小相等
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// 后缓冲的surface的格式为DXGI_FORMAT_R8G8B8A8_UNORM
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// 如果使用垂直同步，设置后缓冲的刷新率
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// 设置后缓冲的用途
// 我们的渲染目标缓冲为后缓冲
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// 后缓冲输出的窗口句柄
swapChainDesc.OutputWindow = hwnd;
// 不使用多重采样
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// 设置全屏或者窗口模式
if(fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
// 设定扫描线ordering以及缩放为unspecified
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// 后缓冲内容呈现到屏幕后，放弃其内容
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//不设置标志
swapChainDesc.Flags = 0;
// 设置feature level为D3D11
// 如果显卡不支持D3D11,我们能够通过设置这个参数，使用D3D10,或者9
featureLevel = D3D_FEATURE_LEVEL_11_0;
// 创建交换链，设备以及设备上下文
result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
&featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, nullptr, &m_deviceContext);
if(FAILED(result))
return false;
// 得到交换链中的后缓冲指针
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBufferPtr);
if(FAILED(result))
return false;
// 用后缓冲创建渲染目标视图
result = m_device->CreateRenderTargetView(backBufferPtr, nullptr, &m_renderTargetView);
if(FAILED(result))
return false;
//释放后缓冲(引用计数减1)
backBufferPtr->Release();
backBufferPtr = nullptr;
// 初始化深度缓冲描述
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
//设置深度缓冲描述
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1; //对于深度缓冲为1
depthBufferDesc.ArraySize = 1; //对于深度缓冲为1，对于纹理，这2个参数有更多用途
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// 创建深度缓冲
result = m_device->CreateTexture2D(&depthBufferDesc, nullptr, &m_depthStencilBuffer);
if(FAILED(result))
return false;
// 初始化深度模版状态描述
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// 设置深度模版状态描述
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
// D3D11_DEPTH_WRITE_MASK_ZERO禁止写深度缓冲
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// 对于front face 像素使用的模版操作操作
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;
// 对于back face像素使用的模版操作模式
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;
//创建深度模版状态
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
return false;
// 设置深度模版状态，使其生效
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// 初始化深度模版视图
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// 设置深度模版视图描述
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// 创建深度模版视图
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
return false;
// 绑定渲染目标视图和深度缓冲到渲染管线
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// 设置光栅化描述，指定多边形如何被渲染
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// 创建光栅化状态
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
return false;
// 设置光栅化状态，使其生效
m_deviceContext->RSSetState(m_rasterState);
// 设置视口，显示全部后缓冲内容
viewport.Width = (FLOAT)screenWidth;
viewport.Height = (FLOAT)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// 创建视口
m_deviceContext->RSSetViewports(1, &viewport);
// 设置透视投影矩阵
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// 创建透视投影矩阵
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
//初始化world矩阵为单位矩阵
//该矩阵实现局部坐标到世界坐标的转换
D3DXMatrixIdentity(&m_worldMatrix);
// 创建正交投影矩阵，主要用来实施2D渲染
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
bool Graphics::Initialize()
{
IDXGIFactory *factory;
IDXGIAdapter *adapter;
IDXGIOutput *adapterOutput;
DXGI_MODE_DESC *displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
D3D11_BLEND_DESC blendDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_SAMPLER_DESC samplerDesc;
unsigned int numModes, i, numerator, denominator, stringLength;
int error;
m_screenSize.cx = m_window->GetSize().cx;
m_screenSize.cy = m_window->GetSize().cy;
RETURN_FAIL( CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory) );
RETURN_FAIL( factory->EnumAdapters(0, &adapter) );
RETURN_FAIL( adapter->EnumOutputs(0, &adapterOutput) );
RETURN_FAIL( adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL) );
displayModeList = new DXGI_MODE_DESC[numModes];
RETURN_FAIL( adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList) );
for(i = 0; i < numModes; ++i)
{
if(displayModeList[i].Width == m_screenSize.cx)
{
if(displayModeList[i].Height == m_screenSize.cy)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
RETURN_FAIL( adapter->GetDesc(&adapterDesc) );
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
RETURN_ERROR( wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128) );
SAFE_DELETE_ARRAY( displayModeList );
SAFE_RELEASE(adapterOutput);
SAFE_RELEASE(adapter);
SAFE_RELEASE(factory);
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.BufferCount = 2;
swapChainDesc.Windowed = true;
swapChainDesc.BufferDesc.Width = m_screenSize.cx;
swapChainDesc.BufferDesc.Height = m_screenSize.cy;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = m_window->GetHWnd();
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
featureLevel = D3D_FEATURE_LEVEL_11_0;
RETURN_FAIL( D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext) );
RETURN_FAIL( m_swapChain->GetParent(__uuidof(IDXGIFactory), (LPVOID*)&factory) );
RETURN_FAIL( factory->MakeWindowAssociation(m_window->GetHWnd(), DXGI_MWA_NO_WINDOW_CHANGES) );
ZeroMemory( &blendDesc, sizeof( blendDesc ) );
blendDesc.AlphaToCoverageEnable = true;
blendDesc.RenderTarget[0].BlendEnable = TRUE;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
RETURN_FAIL( m_device->CreateBlendState( &blendDesc, &m_blendAlpha ) );
m_deviceContext->OMSetBlendState( m_blendAlpha, NULL, 0xFFFFFF );
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
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;
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;
RETURN_FAIL( m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState) );
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
ZeroMemory( &samplerDesc, sizeof( samplerDesc ) );
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
RETURN_FAIL( m_device->CreateSamplerState( &samplerDesc, &m_samplerLinear ) );
return CreateTargets();
}
//---------------------------------------------------------------------
BOOL D3D10VideoModeList::enumerate()
{
// int pD3D = mpDriver->getD3D();
UINT adapter = mpDriver->getAdapterNumber();
HRESULT hr;
IDXGIOutput *pOutput;
for( int iOutput = 0; ; ++iOutput )
{
//AIZTODO: one output for a single monitor ,to be handled for mulimon
hr = mpDriver->getDeviceAdapter()->EnumOutputs( iOutput, &pOutput );
if( DXGI_ERROR_NOT_FOUND == hr )
{
return false;
}
else if (FAILED(hr))
{
return false; //Something bad happened.
}
else //Success!
{
const DXGI_FORMAT allowedAdapterFormatArray[] =
{
DXGI_FORMAT_R8G8B8A8_UNORM, //This is DXUT's preferred mode
//DXGI_FORMAT_R16G16B16A16_FLOAT,
//DXGI_FORMAT_R10G10B10A2_UNORM,
//DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
};
int allowedAdapterFormatArrayCount = sizeof(allowedAdapterFormatArray) / sizeof(allowedAdapterFormatArray[0]);
UINT NumModes = 512;
DXGI_MODE_DESC *pDesc = new DXGI_MODE_DESC[ NumModes ];
hr = pOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,//allowedAdapterFormatArray[f],
0,
&NumModes,
pDesc );
DXGI_OUTPUT_DESC OutputDesc;
pOutput->GetDesc(&OutputDesc);
for( UINT m=0; m<NumModes; m++ )
{
DXGI_MODE_DESC displayMode=pDesc[m];
// Filter out low-resolutions
if( displayMode.Width < 640 || displayMode.Height < 400 )
continue;
// Check to see if it is already in the list (to filter out refresh rates)
BOOL found = FALSE;
vector<D3D10VideoMode>::type::iterator it;
for( it = mModeList.begin(); it != mModeList.end(); it++ )
{
DXGI_OUTPUT_DESC oldOutput= it->getDisplayMode();
DXGI_MODE_DESC oldDisp = it->getModeDesc();
if(//oldOutput.Monitor==OutputDesc.Monitor &&
oldDisp.Width == displayMode.Width &&
oldDisp.Height == displayMode.Height// &&
//oldDisp.Format == displayMode.Format
)
{
// Check refresh rate and favour higher if poss
//if (oldDisp.RefreshRate < displayMode.RefreshRate)
// it->increaseRefreshRate(displayMode.RefreshRate);
found = TRUE;
break;
}
}
if( !found )
mModeList.push_back( D3D10VideoMode( OutputDesc,displayMode ) );
}
}
}
/*
UINT iMode;
for( iMode=0; iMode < pD3D->GetAdapterModeCount( adapter, D3DFMT_R5G6B5 ); iMode++ )
{
DXGI_OUTPUT_DESC displayMode;
pD3D->EnumAdapterModes( adapter, D3DFMT_R5G6B5, iMode, &displayMode );
// Filter out low-resolutions
if( displayMode.Width < 640 || displayMode.Height < 400 )
continue;
// Check to see if it is already in the list (to filter out refresh rates)
BOOL found = FALSE;
vector<D3D10VideoMode>::type::iterator it;
for( it = mModeList.begin(); it != mModeList.end(); it++ )
{
DXGI_OUTPUT_DESC oldDisp = it->getDisplayMode();
if( oldDisp.Width == displayMode.Width &&
oldDisp.Height == displayMode.Height &&
oldDisp.Format == displayMode.Format )
{
// Check refresh rate and favour higher if poss
if (oldDisp.RefreshRate < displayMode.RefreshRate)
it->increaseRefreshRate(displayMode.RefreshRate);
found = TRUE;
break;
}
}
if( !found )
mModeList.push_back( D3D10VideoMode( displayMode ) );
}
for( iMode=0; iMode < pD3D->GetAdapterModeCount( adapter, D3DFMT_X8R8G8B8 ); iMode++ )
{
DXGI_OUTPUT_DESC displayMode;
pD3D->EnumAdapterModes( adapter, D3DFMT_X8R8G8B8, iMode, &displayMode );
// Filter out low-resolutions
if( displayMode.Width < 640 || displayMode.Height < 400 )
continue;
// Check to see if it is already in the list (to filter out refresh rates)
BOOL found = FALSE;
vector<D3D10VideoMode>::type::iterator it;
for( it = mModeList.begin(); it != mModeList.end(); it++ )
{
DXGI_OUTPUT_DESC oldDisp = it->getDisplayMode();
if( oldDisp.Width == displayMode.Width &&
oldDisp.Height == displayMode.Height &&
oldDisp.Format == displayMode.Format )
{
// Check refresh rate and favour higher if poss
if (oldDisp.RefreshRate < displayMode.RefreshRate)
it->increaseRefreshRate(displayMode.RefreshRate);
found = TRUE;
break;
}
}
if( !found )
mModeList.push_back( D3D10VideoMode( displayMode ) );
}
*/
return TRUE;
}
bool initializeEngine()
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
g_swapChain = 0;
g_device = 0;
g_deviceContext = 0;
g_renderTargetView = 0;
g_depthStencilTexture = 0;
g_depthStencilState = 0;
g_depthStencilView = 0;
g_rasterState = 0;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**) &factory);
if (FAILED(result))
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for (i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int) g_screenWidth)
{
if (displayModeList[i].Height == (unsigned int) g_screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
// Store the dedicated video card memory in megabytes.
g_videoCardMemory = (int) (adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, g_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = g_screenWidth;
swapChainDesc.BufferDesc.Height = g_screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = g_hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
swapChainDesc.Windowed = true;
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &g_swapChain, &g_device, NULL, &g_deviceContext);
if (FAILED(result))
{
return false;
}
// Get the pointer to the back buffer.
result = g_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*) &backBufferPtr);
if (FAILED(result))
{
return false;
}
// Create the render target view with the back buffer pointer.
result = g_device->CreateRenderTargetView(backBufferPtr, NULL, &g_renderTargetView);
if (FAILED(result))
{
return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = g_screenWidth;
depthBufferDesc.Height = g_screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_R32_TYPELESS;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = g_device->CreateTexture2D(&depthBufferDesc, NULL, &g_depthStencilTexture);
if (FAILED(result))
{
return false;
}
const char *name = "depth texture";
g_depthStencilTexture->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof(name)-1, name);
g_depthStencilTexture_srv = CreateTextureResourceView(g_depthStencilTexture);
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_EQUAL;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the depth stencil state.
result = g_device->CreateDepthStencilState(&depthStencilDesc, &g_depthStencilState);
if (FAILED(result))
{
return false;
}
// Set the depth stencil state.
g_deviceContext->OMSetDepthStencilState(g_depthStencilState, 1);
// Initialize the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = g_device->CreateDepthStencilView(g_depthStencilTexture, &depthStencilViewDesc, &g_depthStencilView);
if (FAILED(result))
{
return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
g_deviceContext->OMSetRenderTargets(1, &g_renderTargetView, g_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = g_device->CreateRasterizerState(&rasterDesc, &g_rasterState);
if (FAILED(result))
{
return false;
}
// Now set the rasterizer state.
g_deviceContext->RSSetState(g_rasterState);
// Setup the viewport for rendering.
viewport.Width = (float) g_screenWidth;
viewport.Height = (float) g_screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
g_deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float) D3DX_PI / 4.0f;
screenAspect = (float) g_screenWidth / (float) g_screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&g_projectionMatrix, fieldOfView, screenAspect, 0.01, 100);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&g_worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&g_orthoMatrix, (float) g_screenWidth, (float) g_screenHeight, 0.01, 100);
HRESULT hResult = FW1CreateFactory(FW1_VERSION, &pFW1Factory);
pFW1Factory->CreateFontWrapper(g_device, L"Arial", &pFontWrapper);
HRESULT hr = g_deviceContext->QueryInterface( __uuidof(pPerf), reinterpret_cast<void**>(&pPerf) );
CreateDepthStencilStates();
CreateBlendStates();
CreateSamplerStates();
}
bool D3DRenderer::Initialize( int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenFar, float screenNear )
{
// Store the vsync setting.
m_vsync_enabled = vsync;
// Create a DirectX graphics interface factory.
IDXGIFactory* factory;
CHECK( CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory) );
// Use the factory to create an adapter for the primary graphics interface (video card).
IDXGIAdapter* adapter;
CHECK( factory->EnumAdapters( 0, &adapter ) );
// Enumerate the primary adapter output (monitor).
IDXGIOutput* adapterOutput;
CHECK( adapter->EnumOutputs( 0, &adapterOutput ) );
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
unsigned numModes;
CHECK( adapterOutput->GetDisplayModeList( DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, 0 ) );
// Create a list to hold all the possible display modes for this monitor/video card combination.
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
return false;
// Now fill the display mode list structures.
CHECK( adapterOutput->GetDisplayModeList( DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList ) );
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
unsigned numerator, denominator;
for( unsigned i = 0; i < numModes; ++i )
{
if(displayModeList[i].Width == (unsigned)screenWidth)
{
if(displayModeList[i].Height == (unsigned)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description.
DXGI_ADAPTER_DESC adapterDesc;
CHECK( adapter->GetDesc(&adapterDesc) );
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
ReleaseCOM(adapterOutput);
ReleaseCOM(adapter);
ReleaseCOM(factory);
DXGI_SWAP_CHAIN_DESC swapChainDesc;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if(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 of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multi-sampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
CHECK( D3D11CreateDeviceAndSwapChain(0, D3D_DRIVER_TYPE_HARDWARE, 0, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, 0, &m_deviceContext));
// Get the pointer to the back buffer.
ID3D11Texture2D* backBufferPtr;
CHECK( m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr) );
// Create the render target view with the back buffer pointer.
CHECK( m_device->CreateRenderTargetView(backBufferPtr, 0, &m_renderTargetView) );
// Release pointer to the back buffer as we no longer need it.
ReleaseCOM( backBufferPtr );
// Initialize the description of the depth buffer.
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the depth/stencil buffer
CHECK( m_device->CreateTexture2D(&depthBufferDesc, 0, &m_depthStencilBuffer) );
// Initialize the description of the stencil state.
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
// Create the depth stencil state.
CHECK( m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState) );
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// Initialize the depth stencil view.
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
CHECK( m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView) );
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
D3D11_RASTERIZER_DESC rasterDesc;
ZeroMemory(&rasterDesc, sizeof(rasterDesc));
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
CHECK( m_device->CreateRasterizerState(&rasterDesc, &m_rasterState) );
// Now set the rasterizer state.
m_deviceContext->RSSetState(m_rasterState);
// Setup the viewport for rendering.
D3D11_VIEWPORT viewport;
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
float fieldOfView, screenAspect;
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenFar);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&m_worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenFar);
return true;
}
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hWnd, bool fullscreen, float screenDepth, float screenNear)
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
_vsync_enabled = vsync;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
result = adapterOutput->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 = adapterOutput->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 = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
error = wcstombs_s(&stringLength, _videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
delete[] displayModeList;
displayModeList = NULL;
adapterOutput->Release();
adapterOutput = NULL;
adapter->Release();
adapter = NULL;
factory->Release();
factory = NULL;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hWnd;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &_swapChain, &_device, NULL, &_deviceContext);
if (FAILED(result))
{
return false;
}
result = _swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
return false;
}
result = _device->CreateRenderTargetView(backBufferPtr, NULL, &_renderTargetView);
if (FAILED(result))
{
return false;
}
backBufferPtr->Release();
backBufferPtr = NULL;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
result = _device->CreateTexture2D(&depthBufferDesc, NULL, &_depthStencilBuffer);
if (FAILED(result))
{
return false;
}
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
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;
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;
result = _device->CreateDepthStencilState(&depthStencilDesc, &_depthStencilState);
if (FAILED(result))
{
return false;
}
_deviceContext->OMSetDepthStencilState(_depthStencilState, 1);
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
result = _device->CreateDepthStencilView(_depthStencilBuffer, &depthStencilViewDesc, &_depthStencilView);
if (FAILED(result))
{
return false;
}
_deviceContext->OMSetRenderTargets(1, &_renderTargetView, _depthStencilView);
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = _device->CreateRasterizerState(&rasterDesc, &_rasterState);
if (FAILED(result))
{
return false;
}
_deviceContext->RSSetState(_rasterState);
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
_deviceContext->RSSetViewports(1, &viewport);
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
D3DXMatrixPerspectiveFovLH(&_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
D3DXMatrixIdentity(&_worldMatrix);
D3DXMatrixOrthoLH(&_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
bool Direct3D::Initialize(int _screenWidth, int _screenHeight, bool _vsync, HWND _hwnd, bool _fullscreen, float _screenDepth, float _screenNear, TextClass* _timer)
{
HRESULT result;
IDXGIFactory1* factory;
IDXGIAdapter1* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
float fieldOfView, screenAspect;
D3D11_BLEND_DESC blendStateDescription;
bool success;
// Store the vsync setting.
vsync_enabled = _vsync;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&factory);
if (FAILED(result))
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters1(0, &adapter);
if (FAILED(result))
{
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
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;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
// Store the dedicated video card memory in megabytes.
videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
// Release the display mode list.
delete[] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the factory.
factory->Release();
factory = 0;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = _screenWidth;
swapChainDesc.BufferDesc.Height = _screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
// Set the refresh rate of the back buffer.
if (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 of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = _hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if (_fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
//// Set the scan line ordering and scaling to unspecified.
//swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
//swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//// Discard the back buffer contents after presenting.
//swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(adapter,
D3D_DRIVER_TYPE_UNKNOWN,
NULL,
D3D11_CREATE_DEVICE_DEBUG | D3D11_CREATE_DEVICE_BGRA_SUPPORT,
&featureLevel,
1,
D3D11_SDK_VERSION,
&swapChainDesc,
&swapChain,
&device,
NULL,
&deviceContext);
if (FAILED(result))
{
return false;
}
success = _timer->Initialize(device, adapter, _screenWidth, _screenHeight);
if (!success)
{
return false;
}
// Release the adapter.
adapter->Release();
adapter = 0;
// Get the pointer to the back buffer.
result = swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
return false;
}
// Create the render target view with the back buffer pointer.
result = device->CreateRenderTargetView(backBufferPtr, NULL, &backBuffer);
if (FAILED(result))
{
return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = _screenWidth;
depthBufferDesc.Height = _screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = device->CreateTexture2D(&depthBufferDesc, NULL, &depthStencilBuffer);
if (FAILED(result))
{
return false;
}
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
// Create the depth stencil state.
result = device->CreateDepthStencilState(&depthStencilDesc, &depthStencilStateON);
if (FAILED(result))
{
return false;
}
depthStencilDesc.DepthEnable = false;
// Create the depth stencil state.
result = device->CreateDepthStencilState(&depthStencilDesc, &depthStencilStateOFF);
if (FAILED(result))
{
return false;
}
// Set the depth stencil state.
deviceContext->OMSetDepthStencilState(depthStencilStateON, 1);
// Initailze the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = device->CreateDepthStencilView(depthStencilBuffer, &depthStencilViewDesc, &depthStencilView);
if (FAILED(result))
{
return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
deviceContext->OMSetRenderTargets(1, &backBuffer, depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = device->CreateRasterizerState(&rasterDesc, &rasterState);
if (FAILED(result))
{
return false;
}
// Now set the rasterizer state.
deviceContext->RSSetState(rasterState);
// Setup the viewport for rendering.
viewport.Width = (float)_screenWidth;
viewport.Height = (float)_screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float)XM_PI / 4.0f;
screenAspect = (float)_screenWidth / (float)_screenHeight;
// Create the projection matrix for 3D rendering.
DirectX::XMStoreFloat4x4(&projectionMatrix, XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, _screenNear, _screenDepth));
// Create an orthographic projection matrix for 2D rendering.
DirectX::XMStoreFloat4x4(&orthoMatrix, XMMatrixOrthographicLH((float)_screenWidth, (float)_screenHeight, _screenNear, _screenDepth));
// Clear the blend state description.
ZeroMemory(&blendStateDescription, sizeof(D3D11_BLEND_DESC));
// Create an alpha enabled blend state description.
blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_COLOR;
blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;;
blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f;
// Create the blend state using the description.
result = device->CreateBlendState(&blendStateDescription, &alphaEnableBlendingState);
if (FAILED(result))
{
return false;
}
// Modify the description to create an alpha disabled blend state description.
blendStateDescription.RenderTarget[0].BlendEnable = FALSE;
// Create the blend state using the description.
result = device->CreateBlendState(&blendStateDescription, &alphaDisableBlendingState);
if (FAILED(result))
{
return false;
}
renderer = new RenderManager();
if (!renderer)
{
return false;
}
result = renderer->Initialize(device,XMLoadFloat4x4(&projectionMatrix), _screenWidth, _screenHeight);
return true;
}
/*
The Initialize function is what does the entire setup of Direct3D for DirectX 11.
*/
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen,
float screenDepth, float screenNear)
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
D3D11_BLEND_DESC blendStateDescription;
/*
Before we can initialize Direct3D we have to get the refresh rate from the video card/monitor.
Each computer may be slightly different so we will need to query for that information.
We query for the numerator and denominator values and then pass them to DirectX during the setup
and it will calculate the proper refresh rate.
If we don't do this and just set the refresh rate to a default value which may not exist on all
computers then DirectX will respond by performing a blit instead of a buffer flip
which will degrade performance and give us annoying errors in the debug output.
*/
// Store the vsync setting.
m_vsync_enabled = vsync;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
{
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
{
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
{
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
{
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
/*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;
}
}
}*/
numerator = 800;
denominator = 600;
/*
We now have the numerator and denominator for the refresh rate.
The last thing we will retrieve using the adapter is the name of the video card and the
amount of memory on the video card.
*/
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
{
return false;
}
// Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
/*
Now that we have the refresh rate from the system we can start the DirectX initialization.
The first thing we'll do is fill out the description of the swap chain.
The swap chain is the front and back buffer to which the graphics will be drawn.
Generally you use a single back buffer, do all your drawing to it, and then swap it to the
front buffer which then displays on the user's screen. That is why it is called a swap chain.
*/
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1; //count does not include the front buffer
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
/*
The next part of the description of the swap chain is the refresh rate.
The refresh rate is how many times a second it draws the back buffer to the front buffer.
If vsync is set to true in our graphicsclass.h header then this will lock the refresh rate
to the system settings (for example 60hz).
That means it will only draw the screen 60 times a second
(or higher if the system refresh rate is more than 60).
However if we set vsync to false then it will draw the screen as many times a second as it can,
however this can cause some visual artifacts.
*/
// Set the refresh rate of the back buffer.
if(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 of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; //we will be drawing on this buffer
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1; //single sample per pixel
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
/*
After setting up the swap chain description we also need to setup one more variable
called the feature level. This variable tells DirectX what version we plan to use.
Here we set the feature level to 11.0 which is DirectX 11.
*/
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
/*
Now that the swap chain description and feature level have been filled out we can create the swap chain,
the Direct3D device, and the Direct3D device context.
The Direct3D device and Direct3D device context are very important, they are the
interface to all of the Direct3D functions.
We will use the device and device context for almost everything from this point forward.
Those of you reading this who are familiar with the previous versions of DirectX will
recognize the Direct3D device but will be unfamiliar with the new Direct3D device context.
Basically they took the functionality of the Direct3D device and split it up into two
different devices so you need to use both now.
Note that if the user does not have a DirectX 11 video card this function call will
fail to create the device and device context.
Also if you are testing DirectX 11 functionality yourself and don't have a
DirectX 11 video card then you can replace D3D_DRIVER_TYPE_HARDWARE with
D3D_DRIVER_TYPE_REFERENCE and DirectX will use your CPU to draw instead
of the video card hardware.
Note that this runs 1/1000 the speed but it is good for people who don't
have DirectX 11 video cards yet on all their machines.
*/
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(
NULL, //use default graphics adapter
D3D_DRIVER_TYPE_HARDWARE, //hardware graphics acceleration
NULL, //no software driver, we are using hardward driver
0, //set up for single threaded use
&featureLevel, //pointer to D3D feature levels array (enum)
1, //number of elements in previous parameter
D3D11_SDK_VERSION, //macro to set DirectX SDK version number correctly
&swapChainDesc, //pointer to our swap chain description based on our window
&m_swapChain, // out: set our m_swapCain pointer
&m_device, //out: set our m_device pointer
NULL, //out: ptr to D3D_FEATURE_LEVEL of created device
&m_deviceContext); //out: set our m_device_context pointer
if(FAILED(result))
{
return false;
}
/*
Now that we have a swap chain we need to get a pointer to the back buffer and then attach it to the swap chain.
We'll use the CreateRenderTargetView function to attach the back buffer to our swap chain.
*/
// Get the pointer to the back buffer.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
{
return false;
}
// Create the render target view with the back buffer pointer.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
{
return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
/*
We will also need to set up a depth buffer description.
We'll use this to create a depth buffer so that our polygons can be rendered properly in 3D space.
At the same time we will attach a stencil buffer to our depth buffer.
The stencil buffer can be used to achieve effects such as motion blur, volumetric shadows, and other things.
*/
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
/*
Create the depth/stencil buffer using that description.
You will notice we use the CreateTexture2D function to make the buffers, hence the buffer is just a 2D texture.
The reason for this is that once your polygons are sorted and then rasterized they just end up being
colored pixels in this 2D buffer. Then this 2D buffer is drawn to the screen.
*/
// Create the texture for the depth buffer using the filled out description.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
return false;
}
/*
Now we need to setup the depth stencil description.
This allows us to control what type of depth test Direct3D will do for each pixel.
*/
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
/*
With the description filled out we can now create a depth stencil state.
*/
// Create the depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
{
return false;
}
/*
With the created depth stencil state we can now set it so that it takes effect. Notice we use the device context to set it.
*/
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
/*
The next thing we need to create is the description of the view of the depth stencil buffer.
We do this so that Direct3D knows to use the depth buffer as a depth stencil texture.
After filling out the description we then call the function CreateDepthStencilView to create it.
*/
// Initialize the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
return false;
}
/*
Now call OMSetRenderTargets. This will bind the render target view and the depth stencil buffer
to the output render pipeline. This way the graphics that the pipeline renders will
get drawn to our back buffer that we previously created.
With the graphics written to the back buffer we can then swap it to the front and display
our graphics on the user's screen.
*/
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
/*
Now that the render targets are setup we can continue on to some extra functions
that will give us more control over our scenes for future tutorials.
First thing is we'll create is a rasterizer state. This will give us control over how polygons
are rendered. We can do things like make our scenes render in wireframe mode or have
DirectX draw both the front and back faces of polygons.
By default DirectX already has a rasterizer state set up and working
the exact same as the one below but you have no control to change it unless you set up one yourself.
*/
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
{
return false;
}
// Now set the rasterizer state using the device context.
m_deviceContext->RSSetState(m_rasterState);
/*
The viewport also needs to be setup so that Direct3D can map clip space coordinates to the render target space.
Set this to be the entire size of the window.
*/
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
/*
Now we will create the projection matrix. The projection matrix is used to translate the 3D scene
into the 2D viewport space that we previously created.
We will need to keep a copy of this matrix so that we can pass it to our shaders that will be used to render our scenes.
*/
// Setup the projection matrix.
fieldOfView = (float)XM_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
XMStoreFloat4x4(&m_projectionMatrix, XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenDepth));
/*
We will also create another matrix called the world matrix. This matrix is used to convert the vertices of our
objects into vertices in the 3D scene. This matrix will also be used to rotate, translate,
and scale our objects in 3D space. From the start we will just initialize the matrix to the
identity matrix and keep a copy of it in this object. The copy will be needed to be passed
to the shaders for rendering also.
*/
// Initialize the world matrix to the identity matrix.
XMStoreFloat4x4(&m_worldMatrix, XMMatrixIdentity());
/*
And the final thing we will setup in the Initialize function is an orthographic projection matrix.
This matrix is used for rendering 2D elements like user interfaces on the screen allowing us to skip the 3D rendering.
You will see this used in later tutorials when we look at rendering 2D graphics and fonts to the screen.
*/
// Create an orthographic projection matrix for 2D rendering.
XMStoreFloat4x4(&m_orthoMatrix, XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, screenNear, screenDepth));
// blendStateDescription.AlphaToCoverageEnable = TRUE;
// Clear the blend state description.
ZeroMemory(&blendStateDescription, sizeof(D3D11_BLEND_DESC));
// Create an alpha enabled blend state description.
blendStateDescription.AlphaToCoverageEnable = true;
blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;//0x0f;
// Create the blend state using the description.
result = m_device->CreateBlendState(&blendStateDescription, &m_alphaEnableBlendingState);
if(FAILED(result))
{
return false;
}
float blendFactor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
m_deviceContext->OMSetBlendState(m_alphaEnableBlendingState, NULL, 0xFFFFFFFF);
return true;
}
/*
* Initialize()
* brief: This function does all the set up needed for DirectX11.
* param screenWidth: The window width.
* param screenWidth: The window height.
* param vsync: Whether the vsync is activated or not.
* param hwnd: The window handler.
* param fullscreen: Whether if the fullscreen mode is activated or not.
* param screenDepth: The setting to know how far our 3D environment will render.
* param screenNear: The setting to know how near our 3D environment will render.
*/
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen,
float screenFar, float screenNear)
{
//TODO: Split this function in smaller functions. Also, return an error message if failed the initialization to know the reason.
HRESULT hResult;
IDXGIFactory* dxgiFactory;
IDXGIAdapter* dxgiAdapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, numarator, denominator;
unsigned long long stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPntr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterizerDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
m_vSyncEnabled = vsync;
//Create DirectX graphics interface factory.
hResult = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&dxgiFactory);
if (FAILED(hResult))
{
return false;
}
//Use a factory to create an adapter for the primary graphics interface.
hResult = dxgiFactory->EnumAdapters(0, &dxgiAdapter);
if (FAILED(hResult))
{
return false;
}
//Enumerate the primary adapter output (monitor).
hResult = dxgiAdapter->EnumOutputs(0, &adapterOutput);
if (FAILED(hResult))
{
return false;
}
//Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
hResult = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(hResult))
{
return false;
}
//Create a list to hold all the possible display modes for this monitor/video card combinations.
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
//Fill the display mode list structures.
hResult = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(hResult))
{
return false;
}
//Go through all the display modes and find the one that matches the screen width and height.
//When a match is found store the numerator and denominator of the refresh rate for that monitor.
for (unsigned int i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth)
{
if (displayModeList[i].Height == (unsigned int)screenHeight)
{
numarator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
//Get the adapter (video card) descriptor.
hResult = dxgiAdapter->GetDesc(&adapterDesc);
{
if (FAILED(hResult))
{
return false;
}
}
//Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024) / 1024; //Not sure if this is like this, but the parenthesis at the end didn't make sence to me.
//Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
/*We have stored the numerator and denominator for the refresh rate, and we have video card information, time to release the structures
used for that.*/
//Release display mode list.
delete[] displayModeList;
displayModeList = 0;
//Release the adapter output.
adapterOutput->Release();
adapterOutput = nullptr;
//Release the factory.
dxgiFactory->Release();
dxgiFactory = nullptr;
//With the refresh rate saved, it's time to initialize DirectX.
#pragma region SWAP_CHAIN_DESC_INIT
//Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
//Set a single back buffer.
swapChainDesc.BufferCount = 1;
//Set width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
//Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
//Set the refresh rate of the back buffer, using the refresh rate obtained from before and checking the vsync setting.
if (m_vSyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numarator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
//Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
//Set the handler of the window to render to.
swapChainDesc.OutputWindow = hwnd;
//Turn multi-sampling off. *
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
//Set to full screen or windowed mode.
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
//Set scan line ordering and scaling to unspecified. *
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//Discard the back buffer content after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//Don't set the advanced flags.
swapChainDesc.Flags = 0;
#pragma endregion
//Set feature level to DirectX. For now will be 11. TODO: Make it variable.
featureLevel = D3D_FEATURE_LEVEL_11_0;
//Create the swap chain and the DirectX11 device and device context.
hResult = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION,
&swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(hResult))
{
return false;
}
//Get the pointer to the back buffer.
hResult = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPntr);
if (FAILED(hResult))
{
return false;
}
//Create the render target view with the back buffer.
hResult = m_device->CreateRenderTargetView(backBufferPntr, NULL, &m_renderTargetView);
if (FAILED(hResult))
{
return false;
}
//Release the pointer to the back buffer as we no longer need it.
backBufferPntr->Release();
backBufferPntr = nullptr;
//Time to set the depth buffer description. Also will attach a stencil buffer.
//Initialize the description of the back buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
//Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
//Create the texture for the depth buffer using the filled out description.
hResult = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(hResult))
{
return false;
}
//Time to setup the depth stencil descriptor.
//Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
//Setup the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
//Stencil operation 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 operation 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;
//Now, with the description filled, let's create the depth stencil state.
hResult = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(hResult))
{
return false;
}
//With the depth stencil created we can set it so it takes effect. Here the device context is used for it.
//Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
//Initialize the depth stencil view descriptor.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
//Setup the stencil view descriptor.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
//Create the depth stencil view.
hResult = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(hResult))
{
return false;
}
//Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
/*By setting up a raster state we can choose which polygons are rendered and how. With that control
we can draw in wire frame mode or draw both faces of the polygon. DirectX has one default raster state but
we have no control over it and can't change it unless you create one.*/
//Setup the raster description that will determine how and what polygons will be rendered.
rasterizerDesc.AntialiasedLineEnable = false;
rasterizerDesc.CullMode = D3D11_CULL_BACK;
rasterizerDesc.DepthBias = 0;
rasterizerDesc.DepthBiasClamp = 0.0f;
rasterizerDesc.DepthClipEnable = true;
rasterizerDesc.FillMode = D3D11_FILL_SOLID; //change for wire frame mode.
rasterizerDesc.FrontCounterClockwise = false;
rasterizerDesc.MultisampleEnable = false;
rasterizerDesc.ScissorEnable = false;
rasterizerDesc.SlopeScaledDepthBias = 0.0f;
//Create the rasterizer state from the description.
hResult = m_device->CreateRasterizerState(&rasterizerDesc, &m_rasterizerState);
if (FAILED(hResult))
{
return false;
}
//Set the rasterizer state.
m_deviceContext->RSSetState(m_rasterizerState);
/*The viewport also needs to be setup so that Direct3D can map clip space coordinates to the render target space.
Set this to be the entire size of the window.*/
//Setup the view port for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
//Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
//Setup the projection matrix.
fieldOfView = 3.141592654f / 4.0f; //This here is a fixed number. It may be good to play with it to see what happens.
screenAspect = (float)screenWidth / (float)screenHeight;
//Create the projection matrix for 3D rendering.
m_projectionMatrix = XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenFar);
//Setup the world matrix.
m_worldMatrix = XMMatrixIdentity();
/*Here would be the view matrix, but because it is the matrix which will determine our point of view
it seems to be better in the camera class.*/
/*The last thing to set in the initialize function is the orthographic matrix. This matrix will be used
to render the 2D elements (like the GUI) on the screens.*/
//Create an orthographic projection matrix for 2D rendering.
m_orthographicMatrix = XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, screenNear, screenFar);
return true;
}
bool D3DApp::InitGraphicsCard()
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes = 0;
unsigned int numerator = 0;
unsigned int denomenator = 0;
unsigned int stringLength = 0;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
//Create Direct x graphic interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
//use factory now
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result)){ return false; }
//enumerate the primary output (monitor)
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
//Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the monitor
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
//Create a list to hold all the modes for the monitor/video card combo
displayModeList = new DXGI_MODE_DESC[numModes];
//fill the list
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
//Loop through the whole list finding what one equals screen width / height
for (int i = 0; i < numModes; ++i)
{
if (displayModeList[i].Width == (unsigned int)m_ScreenWidth)
{
if (displayModeList[i].Height == (unsigned int)m_ScreenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denomenator = displayModeList[i].RefreshRate.Denominator;
m_MonitorDenumerator = numerator;
m_MonitorNumerator = denomenator;
}
}
}
if (numerator == 0 && denomenator == 0)
{
return false;
}
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
//Store video car memory in MBs
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//Convert the name of the car to a char array
error = wcstombs_s(&stringLength, m_pVideoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
//Release memory
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
return true;
}
bool Direct3D::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
// definitions
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModeCount, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
ID3D11BlendState* blendState;
D3D11_BLEND_DESC blendStateDescription;
float fieldOfView, screenAspect;
///////////////////////////////// GETTING REFRESH RATE
//Create DirectX graphics interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result)) return false;
//Create adapter
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result)) return false;
//Enumerate primary adapter output
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result)) return false;
//Get number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModeCount, NULL);
if (FAILED(result)) return false;
//Create array to hold all possible video modes
displayModeList = new DXGI_MODE_DESC[numModeCount];
if (!displayModeList) return false;
// Fill the array
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModeCount, displayModeList);
if (FAILED(result)) return false;
// find our display mode and get refresh rate for it
for (int i = 0; i < numModeCount; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth &&
displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
// get video card description
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result)) return false;
// get video card memory
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// store
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0) return false;
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
////////////////////////////////////
//////////////// SWAP CHAIN DESCRIPTION
// initialize swap chain description
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// single back buffer
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// setting refresh rate of back buffer
if (m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
/// !! MULTISAMPLING OFF
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen) swapChainDesc.Windowed = false;
else swapChainDesc.Windowed = true;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
///////////////////////////////////////
////////// CREATING DEVICE AND SWAP CHAIN
//DirectX11
featureLevel = D3D_FEATURE_LEVEL_11_0;
//swap chain
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result)) return false;
/*
Sometimes this call to create the device will fail if the primary video card is not compatible with DirectX 11.
Some machines may have the primary card as a DirectX 10 video card and the secondary card as a DirectX 11 video card.
Also some hybrid graphics cards work that way with the primary being the low power Intel card and the secondary being the high power Nvidia card.
To get around this you will need to not use the default device and instead enumerate all the video cards in the machine and
have the user choose which one to use and then specify that card when creating the device.
*/
// get pointer to back buffer
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result)) return false;
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result)) return false;
backBufferPtr->Release();
backBufferPtr = nullptr;
//////////////////////////////////////
////////// DEPTH / STENCIL BUFFER
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// create texture for depth buffer
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result)) return false;
// setup description
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// stencil operations if pixel is front-facing or back-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;
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;
// create state
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// initialize depth stencil view
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// create depth stencil view
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result)) return false;
////////////////////////////////////////////////
// binding target view and depth stencil buffer
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
//////////////////////////////////////////////// DONE
//////// EXTRA STUFF
// raster description - how polygons will be drawn
ZeroMemory(&rasterDesc, sizeof(rasterDesc));
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result)) return false;
m_deviceContext->RSSetState(m_rasterState);
//blending description
//ZeroMemory(&blendStateDescription, sizeof(blendStateDescription));
//blendStateDescription.AlphaToCoverageEnable = true;
//blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
//blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
//blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
//blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
//blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
//blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
//blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
//blendStateDescription.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
//result = m_device->CreateBlendState(&blendStateDescription, &m_blendState);
//if (FAILED(result)) return false;
//const FLOAT blendFactor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
//m_deviceContext->OMSetBlendState(m_blendState, blendFactor, 0xffffffff);
// viewport description
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
m_deviceContext->RSSetViewports(1, &viewport);
//disable depth stencil state
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_depthDisabledStencilState);
if (FAILED(result))return false;
// projection matrix
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// world matrix
D3DXMatrixIdentity(&m_worldMatrix);
// view matrix
////////////////////////////////////////// TBA!!!!!!!
// ortographic projection
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
HRESULT ACD3D::CreateGraphicsDevice(int width, int height)
{
HRESULT hr;
Log("Begin Init Graphics Device");
//inicializa membros
mDriverType = D3D_DRIVER_TYPE_HARDWARE;
mFeatureLevel = D3D_FEATURE_LEVEL_11_0;
ACD3DGlobals::G_pD3dDevice = nullptr;
ACD3DGlobals::G_pContext = nullptr;
//tipo de dispositivo debug ou release
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE( driverTypes );
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
UINT numFeatureLevels = ARRAYSIZE( featureLevels );
//********************************
// cria do dispositivo grafico
//********************************
for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
{
mDriverType = driverTypes[driverTypeIndex];
//passa null no adapter ai ele cria automatico, depois eu recupero para pegar algumas configuracoes
hr = D3D11CreateDevice(nullptr, mDriverType, nullptr, createDeviceFlags, featureLevels,
numFeatureLevels, D3D11_SDK_VERSION, &ACD3DGlobals::G_pD3dDevice,
&mFeatureLevel, &ACD3DGlobals::G_pContext );
if( SUCCEEDED( hr ) )
{
Log("Create graphics device success.");
break;
}
}
if( FAILED( hr ) )
{
MessageBoxA(nullptr, "[ERROR] Create device error. D3DCreateDevice()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
//*********************************
// fim da criacao do dispositivo grafico
//*********************************
IDXGIFactory* pDXGIFactory = ACD3DTools::GetDXGIFactory();
IDXGIAdapter* pDXGIAdapter = ACD3DTools::GetDXGIAdapter();
//usando os objetos acima ele retorna algumas configuracoes
IDXGIOutput* pAdapterOutput;
unsigned int numModes, i, stringLength;
DXGI_MODE_DESC* pDisplayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
// Enumerate the primary adapter output (monitor).
hr = pDXGIAdapter->EnumOutputs(0, &pAdapterOutput);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] EnumOutputs. D3DCreateDevice()", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
hr = pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] GetDisplayModeList", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
pDisplayModeList = new DXGI_MODE_DESC[numModes];
if(!pDisplayModeList)
return AC_FAIL;
// Now fill the display mode list structures.
hr = pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, pDisplayModeList);
if(FAILED(hr))
{
MessageBoxA(nullptr, "[ERROR] GetDisplayModeList", "Error", MB_OK | MB_ICONERROR);
return hr;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for(i=0; i<numModes; i++)
{
if(pDisplayModeList[i].Width == (unsigned int)width)
{
if(pDisplayModeList[i].Height == (unsigned int)height)
{
ACD3DGlobals::G_Numerator = pDisplayModeList[i].RefreshRate.Numerator;
ACD3DGlobals::G_Denomerator = pDisplayModeList[i].RefreshRate.Denominator;
}
}
}
Log("Width: %i. Height: %i", width, height);
// Get the adapter (video card) description.
hr = pDXGIAdapter->GetDesc(&adapterDesc);
if(FAILED(hr))
return hr;
// Store the dedicated video card memory in megabytes.
VideoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
Log("VideoCardMemory: %i (in megabytes).", VideoCardMemory);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, VideoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
Log("[ERROR] Get videocarddescription.");
return AC_FAIL;
}
// Release the display mode list.
SAFE_DELETE_A(pDisplayModeList);
// Release the adapter output.
pAdapterOutput->Release();
pAdapterOutput = nullptr;
// Release the adapter.
pDXGIAdapter->Release();
pDXGIAdapter = nullptr;
// Release the factory.
pDXGIFactory->Release();
pDXGIFactory = nullptr;
Log("End Graphics Device");
return AC_OK;
};
bool D3D11App::initAPI(const API_Revision api_revision, const DXGI_FORMAT backBufferFmt, const DXGI_FORMAT depthBufferFmt, const int samples, const uint flags)
{
backBufferFormat = backBufferFmt;
depthBufferFormat = depthBufferFmt;
msaaSamples = samples;
const bool sampleBackBuffer = (flags & SAMPLE_BACKBUFFER) != 0;
// if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0;
IDXGIFactory1 *dxgiFactory;
if (FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void **) &dxgiFactory)))
{
ErrorMsg("Couldn't create DXGIFactory");
return false;
}
IDXGIAdapter1 *dxgiAdapter;
if (dxgiFactory->EnumAdapters1(0, &dxgiAdapter) == DXGI_ERROR_NOT_FOUND)
{
ErrorMsg("No adapters found");
return false;
}
// DXGI_ADAPTER_DESC1 adapterDesc;
// dxgiAdapter->GetDesc1(&adapterDesc);
IDXGIOutput *dxgiOutput;
if (dxgiAdapter->EnumOutputs(0, &dxgiOutput) == DXGI_ERROR_NOT_FOUND)
{
ErrorMsg("No outputs found");
return false;
}
DXGI_OUTPUT_DESC oDesc;
dxgiOutput->GetDesc(&oDesc);
// Find a suitable fullscreen format
int targetHz = 85;
DXGI_RATIONAL fullScreenRefresh;
int fsRefresh = 60;
fullScreenRefresh.Numerator = fsRefresh;
fullScreenRefresh.Denominator = 1;
char str[128];
uint nModes = 0;
dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, NULL);
DXGI_MODE_DESC *modes = new DXGI_MODE_DESC[nModes];
dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, modes);
resolution->clear();
for (uint i = 0; i < nModes; i++)
{
if (modes[i].Width >= 640 && modes[i].Height >= 480)
{
sprintf(str, "%dx%d", modes[i].Width, modes[i].Height);
int index = resolution->addItemUnique(str);
if (int(modes[i].Width) == fullscreenWidth && int(modes[i].Height) == fullscreenHeight)
{
int refresh = modes[i].RefreshRate.Numerator / modes[i].RefreshRate.Denominator;
if (abs(refresh - targetHz) < abs(fsRefresh - targetHz))
{
fsRefresh = refresh;
fullScreenRefresh = modes[i].RefreshRate;
}
resolution->selectItem(index);
}
}
}
delete [] modes;
sprintf(str, "%s (%dx%d)", getTitle(), width, height);
DWORD wndFlags = 0;
int x, y, w, h;
if (fullscreen)
{
wndFlags |= WS_POPUP;
x = y = 0;
w = width;
h = height;
}
else
{
wndFlags |= WS_OVERLAPPEDWINDOW;
RECT wRect;
wRect.left = 0;
wRect.right = width;
wRect.top = 0;
wRect.bottom = height;
AdjustWindowRect(&wRect, wndFlags, FALSE);
MONITORINFO monInfo;
monInfo.cbSize = sizeof(monInfo);
GetMonitorInfo(oDesc.Monitor, &monInfo);
w = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left);
h = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top);
x = (monInfo.rcWork.left + monInfo.rcWork.right - w) / 2;
y = (monInfo.rcWork.top + monInfo.rcWork.bottom - h) / 2;
}
hwnd = CreateWindow("Game", str, wndFlags, x, y, w, h, HWND_DESKTOP, NULL, hInstance, NULL);
RECT rect;
GetClientRect(hwnd, &rect);
// Create device and swap chain
DWORD deviceFlags = D3D11_CREATE_DEVICE_SINGLETHREADED;
#ifdef _DEBUG
deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL requested_feature_level = (api_revision == D3D11)? D3D_FEATURE_LEVEL_11_0 : (api_revision == D3D11_1)? D3D_FEATURE_LEVEL_10_1 : D3D_FEATURE_LEVEL_10_0;
D3D_FEATURE_LEVEL feature_level;
if (FAILED(D3D11CreateDevice(dxgiAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, deviceFlags, &requested_feature_level, 1, D3D11_SDK_VERSION, &device, &feature_level, &context)))
{
ErrorMsg("Couldn't create D3D11 device");
return false;
}
while (msaaSamples > 0)
{
UINT nQuality;
if (SUCCEEDED(device->CheckMultisampleQualityLevels(backBufferFormat, msaaSamples, &nQuality)) && nQuality > 0)
{
if ((flags & NO_SETTING_CHANGE) == 0) antiAliasSamples = msaaSamples;
break;
}
else
{
msaaSamples -= 2;
}
}
DXGI_SWAP_CHAIN_DESC sd;
memset(&sd, 0, sizeof(sd));
sd.BufferDesc.Width = rect.right;
sd.BufferDesc.Height = rect.bottom;
sd.BufferDesc.Format = backBufferFormat;
sd.BufferDesc.RefreshRate = fullScreenRefresh;
sd.BufferUsage = /*DXGI_USAGE_BACK_BUFFER | */DXGI_USAGE_RENDER_TARGET_OUTPUT | (sampleBackBuffer? DXGI_USAGE_SHADER_INPUT : 0);
sd.BufferCount = 1;
sd.OutputWindow = hwnd;
sd.Windowed = (BOOL) (!fullscreen);
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
sd.SampleDesc.Count = msaaSamples;
sd.SampleDesc.Quality = 0;
if (FAILED(dxgiFactory->CreateSwapChain(device, &sd, &swapChain)))
{
ErrorMsg("Couldn't create swapchain");
return false;
}
// We'll handle Alt-Enter ourselves thank you very much ...
dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
dxgiOutput->Release();
dxgiAdapter->Release();
dxgiFactory->Release();
if (fullscreen)
{
captureMouse(!configDialog->isVisible());
}
renderer = new Direct3D11Renderer(device, context);
if (!createBuffers(sampleBackBuffer))
{
delete renderer;
return false;
}
antiAlias->selectItem(antiAliasSamples / 2);
linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP);
defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp);
blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
noDepthTest = renderer->addDepthState(false, false);
noDepthWrite = renderer->addDepthState(true, false);
cullNone = renderer->addRasterizerState(CULL_NONE);
cullBack = renderer->addRasterizerState(CULL_BACK);
cullFront = renderer->addRasterizerState(CULL_FRONT);
return true;
}
bool D3D::Init(int screenWidth, int screenHeight, bool vsync, HWND hWnd, bool fullscreen, float screenDepth, float screenNear)
{
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModes, i, numerator, denominator, stringLength;
DXGI_MODE_DESC* displayModeList;
DXGI_ADAPTER_DESC adapterDesc;
int error;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* backBufferPtr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
D3D11_BLEND_DESC blendStateDesc;
// Store the vsync setting.
_vsyncEnabled = vsync;
//Create a DirectX graphics interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
return false;
//Use the factory to create an adpater for the primary graphics interface (video card)
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
return false;
//Enumerate the primary adapter output (monitor)
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
return false;
//Get the number of modes that fix the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor)
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
return false;
//Create a list to hold all the possible display modes for this monitor/video card combination
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
return false;
//Now fill the display mode list structures
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
return false;
//Now go through all the displa modes and find the one that matches the screen width and height
//When a match is found store the numerator and denominator of the refresh rate for that monitor
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;
}
}
}
//Get the adapter (video card) description
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
return false;
//Store the dedicated video card memory in mb
_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//Convert eh name of the video card to a char array and store
error = wcstombs_s(&stringLength, _videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
return false;
//Release the display mode list
delete[] displayModeList;
displayModeList = NULL;
//Release the adapter output
adapterOutput->Release();
adapterOutput = NULL;
//release the adapater
adapter->Release();
adapter = NULL;
//Release the factory
factory->Release();
factory = NULL;
//Init the swap chain description
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
//Set to a single back buffer
swapChainDesc.BufferCount = 1;
//Set the width and height of the back buffer
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
//Set regular 32 bit surface for the back buffer
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
//Set the refresh rate of the back buffer
if(_vsyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
//Set the usage of the back buffer
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
//Set the handle for the window to render to
swapChainDesc.OutputWindow = hWnd;
//Turn multisampling off
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
//Set to fullscreen/windows
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
//Set the scan line ordering and scaling to unspecified
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//Discard the back buffer contents after preseting
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
featureLevel = D3D_FEATURE_LEVEL_11_0;
//Create the swap chain, Direct3D device, and device context
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &_swapChain, &_device, NULL, &_deviceContext);
if (FAILED(result))
return false;
//Get the pointer to the back buffer
result = _swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
return false;
//Create the render target view with the back buffer pointer
result = _device->CreateRenderTargetView(backBufferPtr, NULL, &_renderTargetView);
if (FAILED(result))
return false;
//Release pointer to the back buffer as we no longer need it
backBufferPtr->Release();
backBufferPtr = NULL;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = _device->CreateTexture2D(&depthBufferDesc, NULL, &_depthStencilBuffer);
if(FAILED(result))
return false;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
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;
// Create the depth stencil state.
result = _device->CreateDepthStencilState(&depthStencilDesc, &_depthStencilState);
if(FAILED(result))
return false;
//Set the depth stencil state
_deviceContext->OMSetDepthStencilState(_depthStencilState, 1);
//Init the depth stencil view
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
//Set up the depth stencil view desc
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = _device->CreateDepthStencilView(_depthStencilBuffer, &depthStencilViewDesc, &_depthStencilView);
if(FAILED(result))
return false;
// Bind the render target view and depth stencil buffer to the output render pipeline.
_deviceContext->OMSetRenderTargets(1, &_renderTargetView, _depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = _device->CreateRasterizerState(&rasterDesc, &_rasterState);
if(FAILED(result))
{
return false;
}
// Now set the rasterizer state.
_deviceContext->RSSetState(_rasterState);
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
_deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&_worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
//Clear the second depth stencil state before setting params
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering. The only difference is
// that DepthEnable is set to false, all other parameters are the same as the other depth stencil state.
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//Create the state using the device
result = _device->CreateDepthStencilState(&depthDisabledStencilDesc, &_depthDisabledStencilState);
if (FAILED(result))
return false;
//Clear the blend state desc
ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC));
// Create an alpha enabled blend state description.
blendStateDesc.RenderTarget[0].BlendEnable = TRUE;
blendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
//Create the blend state using the desciption
result = _device->CreateBlendState(&blendStateDesc, &_aEnableBlendingState);
if (FAILED(result))
return false;
//Modify the desciption to create an alpha disabled blend state desc
blendStateDesc.RenderTarget[0].BlendEnable = FALSE;
//Create the blend state using the desc
result = _device->CreateBlendState(&blendStateDesc, &_aDisableBlendingState);
if (FAILED(result))
return false;
return true;
}
bool CD3DGraphics11::Init(HWND hWnd, UINT clientWidth, UINT clientHeight )
{
cout << "CD3DGraphics11: Client Height " << clientHeight <<"\n";
cout << "CD3DGraphics11: Client Width " << clientWidth << "\n";
m_clientHeight = clientHeight;
m_clientWidth = clientWidth;
int screenWidth = GetSystemMetrics(SM_CXSCREEN);
int screenHeight = GetSystemMetrics(SM_CYSCREEN);
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* pBackBuffer;
IDXGIFactory* pFactory;
IDXGIAdapter* pAdapter;
IDXGIOutput* pAdapterOutput;
D3D11_VIEWPORT viewport;
DXGI_MODE_DESC* pDisplayModeList;
DXGI_ADAPTER_DESC adapterDesc;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDisabledDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_BLEND_DESC blendDesc;
UINT nAdapterModes = 0;
int RRNumerator = 0, RRDenominator = 1;
if(FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory),(void**)&pFactory))){return false;}
if(FAILED(pFactory->EnumAdapters(0,&pAdapter))){return false;}
if(FAILED(pAdapter->EnumOutputs(0,&pAdapterOutput))){return false;}
if(FAILED(pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &nAdapterModes, NULL))){return false;}
pDisplayModeList = new DXGI_MODE_DESC[nAdapterModes];
if(!pDisplayModeList){ return false; }
if(FAILED(pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &nAdapterModes, pDisplayModeList ))){return false;}
if(m_vsync)
{
for(UINT i = 0; i < nAdapterModes; i++)
{
if( pDisplayModeList[i].Width == screenWidth &&
pDisplayModeList[i].Height == screenHeight )
{
RRNumerator = pDisplayModeList[i].RefreshRate.Numerator;
RRDenominator = pDisplayModeList[i].RefreshRate.Denominator;
break;
}
}
}
if(FAILED(pAdapter->GetDesc(&adapterDesc))){return false;}
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024 );
if(wcstombs_s(NULL, m_videoCardDesc,128,adapterDesc.Description,128) != 0){return false;}
MEMORY::DX::SafeRelease(pAdapterOutput);
MEMORY::DX::SafeRelease(pAdapter);
MEMORY::DX::SafeRelease(pFactory);
ZeroMemory(&swapChainDesc,sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.Flags = 0;
swapChainDesc.Windowed = true;
swapChainDesc.OutputWindow = hWnd;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferDesc.Height = clientHeight;
swapChainDesc.BufferDesc.Width = clientWidth;
swapChainDesc.BufferDesc.RefreshRate.Denominator = RRDenominator;
swapChainDesc.BufferDesc.RefreshRate.Numerator = RRNumerator;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
featureLevel = D3D_FEATURE_LEVEL_11_0;
UINT flags = 0;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
if(FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE,NULL, flags,&featureLevel,1,
D3D11_SDK_VERSION,&swapChainDesc,&m_pSwapChain,
&m_device.pDevice,NULL,&m_device.pDeviceContext))) {return false;}
if(FAILED(m_pSwapChain->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&pBackBuffer))){return false;}
if(FAILED(m_device.pDevice->CreateRenderTargetView(pBackBuffer, NULL, &m_pRenderTargetView))){return false;}
MEMORY::DX::SafeRelease(pBackBuffer);
ZeroMemory(&depthBufferDesc,sizeof(D3D11_TEXTURE2D_DESC));
depthBufferDesc.ArraySize = 1;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.Height = clientHeight;
depthBufferDesc.Width = clientWidth;
depthBufferDesc.MiscFlags = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
if(FAILED(m_device.pDevice->CreateTexture2D(&depthBufferDesc,NULL,&m_pDepthStencilBuffer))){return false;}
ZeroMemory(&depthStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
if(FAILED(m_device.pDevice->CreateDepthStencilState(&depthStencilDesc,&m_pDepthStencilState))){return false;}
ZeroMemory(&depthStencilDisabledDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
depthStencilDisabledDesc.DepthEnable = false;
depthStencilDisabledDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDisabledDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDisabledDesc.StencilEnable = true;
depthStencilDisabledDesc.StencilReadMask = 0xFF;
depthStencilDisabledDesc.StencilWriteMask = 0xFF;
depthStencilDisabledDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDisabledDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDisabledDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDisabledDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
if (FAILED(m_device.pDevice->CreateDepthStencilState(&depthStencilDisabledDesc, &m_pDepthStencilStateDisabled))) { return false; }
m_device.pDeviceContext->OMSetDepthStencilState(m_pDepthStencilState,1);
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;
if(FAILED(m_device.pDevice->CreateDepthStencilView(m_pDepthStencilBuffer,
&depthStencilViewDesc,&m_pDepthStencilView ))) {return false; }
ZeroMemory(&blendDesc,sizeof(D3D11_BLEND_DESC));
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA;
blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
blendDesc.AlphaToCoverageEnable = true;
if(FAILED(m_device.pDevice->CreateBlendState(&blendDesc,&m_pAlphaBlendEnabled)))
return false;
blendDesc.RenderTarget[0].BlendEnable = false;
blendDesc.AlphaToCoverageEnable = false;
if(FAILED(m_device.pDevice->CreateBlendState(&blendDesc, &m_pAlphaBlendDisabled)))
return false;
rasterDesc.AntialiasedLineEnable = true;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = true;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
if(FAILED(m_device.pDevice->CreateRasterizerState(&rasterDesc,&m_pRasterState))){return false;}
m_device.pDeviceContext->RSSetState(m_pRasterState);
rasterDesc.CullMode = D3D11_CULL_NONE;
if (FAILED(m_device.pDevice->CreateRasterizerState(&rasterDesc, &m_pRasterStateNoCull))) { return false; }
viewport.Height = (float)clientHeight;
viewport.Width = (float)clientWidth;
viewport.MaxDepth = 1.0f;
viewport.MinDepth = 0.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
m_device.pDeviceContext->OMSetRenderTargets(1,&m_pRenderTargetView,m_pDepthStencilView);
m_device.pDeviceContext->RSSetViewports(1,&viewport);
float fov, screenAspect;
fov = (float)D3DX_PI / 4.0f;
screenAspect = (float)clientWidth / (float)clientHeight;
D3DXMatrixPerspectiveFovLH(&m_matrices.projection,fov,screenAspect,0.1f,1000.0f);
D3DXMatrixOrthoLH(&m_matrices.ortho,(float)clientWidth,(float)clientHeight,0.1f,1000.0f);
if (!InitDefaultTexture())
return false;
if(!m_colorShader.Init(*this))
return false;
if(!m_textureShader.Init(*this))
return false;
if(!m_textureLightingShader.Init(*this))
return false;
if(!m_orthoShader.Init(*this))
return false;
if (!m_specularMapShader.Init(*this))
return false;
if (!m_bumpMapShader.Init(*this))
return false;
return true;
}
