I am trying to learn DX11 but so far I am not having a lot of luck, I currently have a few simple draw calls that should display a quad and a debug axis at the origin.

However nothing is drawn and when I look at the drawcalls in PIX i see that the vertices get transformed fine but the viewport stays empty, here is a PIX screenshot showing what I mean.


Now I can't seem to find what I am doing wrong in the D3D11 initialisation steps so here they are:

void RenderSystem::initialise()
{
m_appName = "Demo app";
m_windowName = "Demo app";
if (m_window.createWindow(m_appName, m_windowName))
{
m_window.initialise();
m_window.showWindow();
}
//Enumerate which devices we can create and which ones we want to create.
HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&m_dxgiFactory);
if (FAILED(hr))
{
std::cout << "Failed to create a dxgi factory, can't enumerate adapaters, with error: " << hr << std::endl;
}
std::cout << "Setting up a Render Device" << std::endl;
UINT i = 0;
IDXGIAdapter * pAdapter;
std::vector <IDXGIAdapter*> vAdapters;
while(m_dxgiFactory->EnumAdapters(i, &pAdapter) != DXGI_ERROR_NOT_FOUND)
{
vAdapters.push_back(pAdapter);
++i;
}
//release the factory here we need to get the factory the device is created with later on otherwise swapchain creation fails
m_dxgiFactory->Release();
DeviceManager& deviceManager = DeviceManager::getInstance();
if (!deviceManager.createDevice(vAdapters))
{
ExitProcess(1);
}
ID3D11Device* device = deviceManager.getDevice();
//Patch up the factory
patchUpDXGIFactory(device);
int windowWidth = 1280;
int windowHeight = 720;
const ISetting<int>* widthSetting = SettingsManager::getInstance().getSetting<int>("WindowWidth");
if (widthSetting)
{
windowWidth = widthSetting->getData();
}
const ISetting<int>* heightSetting = SettingsManager::getInstance().getSetting<int>("WindowHeight");
if (heightSetting)
{
windowHeight = heightSetting->getData();
}
createSwapChain(device, windowWidth, windowHeight);
setupSwapChainForRendering(device, deviceManager.getDeviceContext(), windowWidth, windowHeight);
//Everything is in GL format so turn off culling
D3D11_RASTERIZER_DESC rasterizerStateDesc;
rasterizerStateDesc.CullMode = D3D11_CULL_NONE;
rasterizerStateDesc.FillMode = D3D11_FILL_SOLID;
rasterizerStateDesc.AntialiasedLineEnable = false;
rasterizerStateDesc.DepthBias = 0;
rasterizerStateDesc.DepthBiasClamp = 0.0f;
rasterizerStateDesc.FrontCounterClockwise = false;
rasterizerStateDesc.MultisampleEnable = false;
rasterizerStateDesc.ScissorEnable = false;
rasterizerStateDesc.SlopeScaledDepthBias = 0.0f;
rasterizerStateDesc.DepthClipEnable = true;
hr = device->CreateRasterizerState(&rasterizerStateDesc, &m_rasteriserState);

#ifdef _DEBUG
m_debugAxis.initialise();
#endif
m_face.initialise(0.5f, false, false, true);
Matrix44 world;
world.identity();
m_face.transform(world);
}
//-----------------------------------------------------------------------------
//! @brief TODO enter a description
//! @remark
//-----------------------------------------------------------------------------
void RenderSystem::update( float elapsedTime, double time )
{
m_window.update(elapsedTime, time);
float clearColor[4] = {0.9f, 0.5f, 0.5f, 1.0f};
ID3D11DeviceContext* deviceContext = DeviceManager::getInstance().getDeviceContext();
deviceContext->ClearRenderTargetView(m_renderTargetView, clearColor);
deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
deviceContext->RSSetState(m_rasteriserState);

m_face.draw();
#ifdef _DEBUG
m_debugAxis.draw(deviceContext);
#endif
m_swapChain->Present(0,0);
}
//-----------------------------------------------------------------------------
//! @brief TODO enter a description
//! @remark
//-----------------------------------------------------------------------------
bool RenderSystem::createSwapChain(ID3D11Device* device, int windowWidth, int windowHeight)
{
DXGI_MODE_DESC bufferDescription;
ZeroMemory(&bufferDescription, sizeof(DXGI_MODE_DESC));
bufferDescription.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
bufferDescription.Height = windowHeight;
bufferDescription.Width = windowWidth;
bufferDescription.RefreshRate.Numerator = 60;
bufferDescription.RefreshRate.Denominator = 1;
m_swapChainDescriptor.BufferCount = 1;
m_swapChainDescriptor.BufferDesc = bufferDescription;
m_swapChainDescriptor.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
m_swapChainDescriptor.OutputWindow = m_window.getWindowHandle();
m_swapChainDescriptor.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
m_swapChainDescriptor.SampleDesc.Count = 1;
m_swapChainDescriptor.SampleDesc.Quality = 0;
m_swapChainDescriptor.Windowed = true;
if (FAILED(m_dxgiFactory->CreateSwapChain((IUnknown*)device, &m_swapChainDescriptor, &m_swapChain)))
{
std::cout << "Failed to create a swapchain" << std::endl;
return false;
}
return true;
}

//-----------------------------------------------------------------------------
//! @brief TODO enter a description
//! @remark
//-----------------------------------------------------------------------------
void RenderSystem::setupSwapChainForRendering( ID3D11Device* device, ID3D11DeviceContext* deviceContext, int windowWidth, int windowHeight )
{
// Create a render target view
if( FAILED( m_swapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&m_backBuffer ) ) )
{
std::cout << "Failed to acquire the back buffer pointer" << std::endl;
}
if( FAILED( device->CreateRenderTargetView( m_backBuffer, NULL, &m_renderTargetView ) ) )
{
std::cout << "Failed to Create the render target view" << std::endl;
}
m_backBuffer->Release();
// Create depth stencil texture
D3D11_TEXTURE2D_DESC depthBufferDescriptor;
ZeroMemory( &depthBufferDescriptor, sizeof(D3D11_TEXTURE2D_DESC) );
depthBufferDescriptor.Width = windowWidth;
depthBufferDescriptor.Height = windowHeight;
depthBufferDescriptor.MipLevels = 1;
depthBufferDescriptor.ArraySize = 1;
depthBufferDescriptor.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDescriptor.SampleDesc.Count = 1;
depthBufferDescriptor.SampleDesc.Quality = 0;
depthBufferDescriptor.Usage = D3D11_USAGE_DEFAULT;
depthBufferDescriptor.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDescriptor.CPUAccessFlags = 0;
depthBufferDescriptor.MiscFlags = 0;
if( FAILED( device->CreateTexture2D( &depthBufferDescriptor, NULL, &m_depthStencilBuffer ) ) )
{
std::cout << "Failed to create the back buffer" << std::endl;
}

// Create the depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDescriptor;
ZeroMemory( &depthStencilViewDescriptor, sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC) );
depthStencilViewDescriptor.Format = depthBufferDescriptor.Format;
depthStencilViewDescriptor.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDescriptor.Texture2D.MipSlice = 0;
if( FAILED(device->CreateDepthStencilView( m_depthStencilBuffer, &depthStencilViewDescriptor, &m_depthStencilView )) )
{
std::cout << "Failed to create the depth stencil view" << std::endl;
}
deviceContext->OMSetRenderTargets( 1, &m_renderTargetView, m_depthStencilView );

//// Setup the viewport
D3D11_VIEWPORT vp;
vp.Width = (FLOAT)windowWidth;
vp.Height = (FLOAT)windowHeight;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
deviceContext->RSSetViewports( 1, &vp );
}


Non of the calls seem to fail however I am not seeing a quad in the output target, so can anyone see what I am doing wrong here?

If it's not showing up in the viewport window then it has to be something before the pixel shader kicks in. So either the viewport is wrong (although it looks right in your code), or your triangles are getting backface culled, or the triangles aren't on the screen to begin with.

Sorry should have mentioned a few more things, RasteriserState is set to not back or front face cull so we should always see the quad. Quad is created around the origin (one of it's corners is on the origin) has an identity world matrix and then just a LH view and perspective matrix for transformation.

Camera is created with the following line, so should be looking at (0,0,0) and located in (0,0,2)

m_cameraSystem.createCamera("global", Vector3(0.0f, 0.0f, 2.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3::yAxis());


Pixel shader is only outputting a full alpha white color as I don't care about shading at the moment just want to see the object on screen.

I am just at a loss here, in DX9.0 I would have this rendering as I said before, but I can't see what I am missing in DX11. Also I am running with full debug information on and that is not giving me warnings or usefull info traces as to why it shouldn't be rendering.

So I think I found it:
When I turn rasterizerStateDesc.DepthClipEnable off I can actually see my quad so must be something to do with the depthstencilstate.