d3d initiate code
CString CRender::Initiate(void)
{
CString retval;
HRESULT hr;
DXGI_ADAPTER_DESC Desc;
hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&m_pFactory));
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::CreateDXGIFactory] ") + ConvertDXError(hr), ET_Error);
}
if(m_pFactory->EnumAdapters(0, &m_pAdapter) == DXGI_ERROR_NOT_FOUND)
{
Shutdown();
return CShared::m_pError->PushError("[CRender::Initiate::m_pFactory->EnumAdapters] DXGI_ERROR_NOT_FOUND", ET_Error);
}
hr = m_pAdapter->GetDesc(&Desc);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pAdapter->GetDesc] ") + ConvertDXError(hr), ET_Error);
}
// TODO: this is adding a space at the end... it has something to do with wchar_t stuff
CShared::m_pLog->Print(CString::Format(L"%s", Desc.Description));
CShared::m_pLog->Print(CString::Format("\n Dedicated video memory: %0.2f MB\n Dedicated system memory: %0.2f MB\n Shared system memory: %0.2f MB\n",
(float)Desc.DedicatedVideoMemory / (1024 * 1024), (float)Desc.DedicatedSystemMemory / (1024 * 1024), (float)Desc.SharedSystemMemory / (1024 * 1024)));
// TODO: get outputs, display modes, refresh rates, etc
// TODO: check to make sure requirements are met
// create window
m_pWindow = new CWindow();
assert(m_pWindow != 0);
if((m_cvarFullscreen.GetValue()).bVal)
retval = m_pWindow->Create(WINDOW_TITLE, -1, -1);
else
retval = m_pWindow->Create(WINDOW_TITLE, m_cvarResolutionWidth.GetValue(), m_cvarResolutionHeight.GetValue());
if(retval != "OK")
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pWindow->Create] ") + retval, ET_Error);
}
// TODO: if fullscreen window size does not match cvars, change cvars to match it here
D3D_FEATURE_LEVEL featurelevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
D3D_FEATURE_LEVEL featurelevelcreated;
UINT flags = 0;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
CShared::m_pLog->Print("D3D11_CREATE_DEVICE_DEBUG\n");
#endif
DXGI_SWAP_CHAIN_DESC scd;
memset(&scd, 0, sizeof(DXGI_SWAP_CHAIN_DESC));
scd.BufferCount = 1;
scd.BufferDesc.Width = (long)m_cvarResolutionWidth.GetValue();
scd.BufferDesc.Height = (long)m_cvarResolutionHeight.GetValue();
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferDesc.RefreshRate.Numerator = 60;
scd.BufferDesc.RefreshRate.Denominator = 1;
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scd.OutputWindow = (*m_pWindow);
scd.SampleDesc.Count = 1;
scd.SampleDesc.Quality = 0;
scd.Windowed = TRUE; // always true since fullscreen mode is just a window covering the entire screen
hr = D3D11CreateDeviceAndSwapChain(m_pAdapter,
D3D_DRIVER_TYPE_UNKNOWN,
NULL,
flags,
featurelevels,
sizeof(featurelevels) / sizeof(featurelevels[0]),
D3D11_SDK_VERSION,
&scd,
&m_pSwapChain,
&m_pDevice,
&featurelevelcreated,
&m_pImmediateContext);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::D3D11CreateDevice] ") + ConvertDXError(hr), ET_Error);
}
// check which version was created
switch(featurelevelcreated)
{
case D3D_FEATURE_LEVEL_11_0:
CShared::m_pLog->Print("D3D_FEATURE_LEVEL_11_0\n");
break;
case D3D_FEATURE_LEVEL_10_1:
CShared::m_pLog->Print("D3D_FEATURE_LEVEL_10_1\n");
break;
case D3D_FEATURE_LEVEL_10_0:
CShared::m_pLog->Print("D3D_FEATURE_LEVEL_10_0\n");
break;
default: // unsupported version created
// TODO: quit normally but continue if the m_cvar is set to ignore this
break;
}
ID3D11Texture2D *pBuffer = 0;
hr = m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBuffer);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pSwapChain->GetBuffer] ") + ConvertDXError(hr), ET_Error);
}
hr = m_pDevice->CreateRenderTargetView(pBuffer, NULL, &m_pRenderTargetView);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pDevice->CreateRenderTargetView] ") + ConvertDXError(hr), ET_Error);
}
pBuffer->Release();
m_pImmediateContext->OMSetRenderTargets(1, &m_pRenderTargetView, NULL);
D3D11_VIEWPORT vp;
vp.Width = (FLOAT)m_cvarResolutionWidth.GetValue();
vp.Height = (FLOAT)m_cvarResolutionHeight.GetValue();
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
m_pImmediateContext->RSSetViewports(1, &vp);
// create the console's vertex buffer
CVector3D verts[] = {
CVector3D(-1.0f, 0.0f, 0.0f), // bottom left
CVector3D(-1.0f, 1.0f, 0.0f), // top left
CVector3D(1.0f, 0.0f, 0.0f), // bottom right
CVector3D(1.0f, 1.0f, 0.0f), // top right
};
D3D11_BUFFER_DESC bd;
memset(&bd, 0, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.ByteWidth = sizeof(CVector3D) * 4;
D3D11_SUBRESOURCE_DATA sd;
memset(&sd, 0, sizeof(sd));
sd.pSysMem = verts;
hr = m_pDevice->CreateBuffer(&bd, &sd, &m_pvbConsole);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pDevice->CreateBuffer] ") + ConvertDXError(hr), ET_Error);
}
// set up the console's vertex shader
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
ID3DBlob *pShader = 0;
ID3DBlob *pErrorMsgs = 0;
unsigned int uiFlags = D3DCOMPILE_ENABLE_STRICTNESS, uiLayoutSize = sizeof(layout) / sizeof(layout[0]);
#ifdef _DEBUG
uiFlags |= D3DCOMPILE_DEBUG;
#endif
hr = D3DX11CompileFromFile("console.fx", NULL, NULL, "VS", "vs_4_0", uiFlags, 0, NULL, &pShader, &pErrorMsgs, NULL);
if(pErrorMsgs)
{
CShared::m_pLog->Print(CString(static_cast<char*>(pErrorMsgs->GetBufferPointer())) + "\n");
pErrorMsgs->Release();
pErrorMsgs = 0;
}
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::D3DX11CompileFromFile] ") + ConvertDXError(hr), ET_Error);
}
hr = m_pDevice->CreateVertexShader(pShader->GetBufferPointer(), pShader->GetBufferSize(), NULL, &m_pvsConsole);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pDevice->CreateVertexShader] ") + ConvertDXError(hr), ET_Error);
}
hr = m_pDevice->CreateInputLayout(layout, uiLayoutSize, pShader->GetBufferPointer(), pShader->GetBufferSize(), &m_pilConsole);
pShader->Release();
pShader = 0;
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pDevice->CreateInputLayout] ") + ConvertDXError(hr), ET_Error);
}
// set up the pixel shader for the console
hr = D3DX11CompileFromFile("console.fx", NULL, NULL, "PS", "ps_4_0", uiFlags, 0, NULL, &pShader, &pErrorMsgs, NULL);
if(pErrorMsgs)
{
CShared::m_pLog->Print(CString(static_cast<char*>(pErrorMsgs->GetBufferPointer())) + "\n");
pErrorMsgs->Release();
pErrorMsgs = 0;
}
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::D3DX11CompileFromFile] ") + ConvertDXError(hr), ET_Error);
}
hr = m_pDevice->CreatePixelShader(pShader->GetBufferPointer(), pShader->GetBufferSize(), NULL, &m_ppsConsole);
if(FAILED(hr))
{
Shutdown();
return CShared::m_pError->PushError(CString("[CRender::Initiate::m_pDevice->CreatePixelShader] ") + ConvertDXError(hr), ET_Error);
}
pShader->Release();
pShader = 0;
return "OK";
}
drawing code
float color[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
m_pImmediateContext->ClearRenderTargetView(m_pRenderTargetView, color);
unsigned int uiStride = sizeof(CVector3D);
unsigned int uiOffset = 0;
m_pImmediateContext->IASetInputLayout(m_pilConsole);
m_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
m_pImmediateContext->IASetVertexBuffers(0, 1, &m_pvbConsole, &uiStride, &uiOffset);
m_pImmediateContext->VSSetShader(m_pvsConsole, NULL, 0);
m_pImmediateContext->PSSetShader(m_ppsConsole, NULL, 0);
m_pImmediateContext->Draw(4, 0);
m_pSwapChain->Present((m_cvarVSync.GetValue()).bVal ? 1 : 0, 0);
shader code
//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
float4 VS( float4 Pos : POSITION ) : SV_POSITION
{
return Pos;
}
//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 PS( float4 Pos : SV_POSITION ) : SV_Target
{
return float4(1.0f, 0.0f, 0.0f, 1.0f);
}