Directx11 Rendering with C++ Not Working - c++

Question

I started to practice rendering with directx11.I had done rendering in directx 9. But DX11 is a pain in the ass.. I couldn't manage to even draw a simple traingle. I dont know what I am doing wrong.
I tried removing depth and stencil buffer but was in vain.
So after brooding over this issue for 2 hours i still can't find the solution.
Can anyone please be kind enough to help me.. Please guys
Thanks
Here is the full code
#include <Windows.h>
#include <windowsx.h>
#include <D3D11.h>
#include <D3DX10math.h>
#include <dxerr.h>
#include <D3DX11.h>
#include <D3DX10.h>
#include "CoreApp.h"
#include "AppTime.h"
using namespace std;
#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "d3dx11.lib")
#pragma comment (lib, "d3dx10.lib")
LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
bool InitWindowClass(HINSTANCE hinst,int shw,HWND * _hwnd,WNDCLASSEX * exClass);
RECT windowWidth = {0,0, 512,512};
void TW_CALL _Callbak(void * clenddata);
void InitPipeline();
void initGraphics();
ID3D11VertexShader * vshader = 0;
ID3D11PixelShader * pixelShader = 0;
ID3D11Device * d3dDevice = 0;
ID3D11DeviceContext * d3dContext = 0;
#pragma region verticles
struct CVertex
{
float X,Y,Z;
D3DXCOLOR col;
};
namespace Color
{
D3DXCOLOR white (255);
D3DXCOLOR Red ((float)255,0.0,0.0,1.0);
}
#pragma endregion
int WINAPI WinMain(HINSTANCE inst,HINSTANCE previnst,LPSTR cmdLine,int show)
{
// Window Params
HWND hwnd;
WNDCLASSEX exClass;
MSG msg;
GameTime time;
// Iniitaliztion
SecureZeroMemory(&hwnd,sizeof(HWND));
SecureZeroMemory(&exClass,sizeof(exClass));
SecureZeroMemory(&msg,sizeof(MSG));
SecureZeroMemory(&time,sizeof(time));
if(InitWindowClass(inst,show,&hwnd,&exClass))
{
// Directx 11 Functionalities
#pragma region Create the device
D3D_FEATURE_LEVEL feature_LEVEL; // Output feature level
HRESULT hr = D3D11CreateDevice(0,
D3D_DRIVER_TYPE_HARDWARE,
0,
0, // No flags
0,0,
D3D11_SDK_VERSION,
&d3dDevice,
&feature_LEVEL,&d3dContext);
if(FAILED(hr))
{
MessageBox(hwnd,L"Failed TO CREATE DEVICE",L"ERROR",0);
}
#pragma endregion
#pragma region Multisampling
UINT multisampleQuality = 0;
d3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_B8G8R8A8_UNORM,4,&multisampleQuality);
#pragma endregion
#pragma region DescribeSwapChain
DXGI_SWAP_CHAIN_DESC swapDesc;
// Allocate Mommory
SecureZeroMemory(&swapDesc,sizeof(DXGI_SWAP_CHAIN_DESC));
swapDesc.BufferDesc.Width = 512;
swapDesc.BufferDesc.Height = 512;
swapDesc.BufferDesc.RefreshRate.Numerator= 60;
swapDesc.BufferDesc.RefreshRate.Denominator = 1;
swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
swapDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//MSAA
swapDesc.SampleDesc.Count = 4;
swapDesc.SampleDesc.Quality = multisampleQuality -1;
//BackBuffer
swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapDesc.BufferCount = 1;
swapDesc.OutputWindow = hwnd;
swapDesc.Windowed = true;
swapDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
#pragma endregion
#pragma region CreateSwapChain
#pragma region Obtain DXGIFactory
// DXGIFactory >> DXGIAdaptor >> DXGIDevice
// Get the DXGI device
IDXGIDevice * dxgiDevice = 0;
d3dDevice->QueryInterface(__uuidof(IDXGIDevice),(void**)&dxgiDevice);
// Obtain DXGIAdaptor
IDXGIAdapter * dxgiAdaptor = 0;
dxgiDevice->GetParent(__uuidof(IDXGIAdapter),(void**)&dxgiAdaptor);
IDXGIFactory * dxgiFactory = 0;
dxgiAdaptor->GetParent(__uuidof(IDXGIFactory),(void**)&dxgiFactory);
#pragma endregion
IDXGISwapChain * SwapChain = 0;
if(FAILED(dxgiFactory->CreateSwapChain(d3dDevice,&swapDesc,&SwapChain)))
{
MessageBox(hwnd,L"Failed Creating back buffer",L"Error",0);
}
dxgiFactory->MakeWindowAssociation(hwnd,0);
//Release COMs
dxgiAdaptor->Release();
dxgiDevice->Release();
dxgiFactory->Release();
/*IDXGISwapChain * SwapChain = 0;
if(FAILED(D3D11CreateDeviceAndSwapChain(0,D3D_DRIVER_TYPE_HARDWARE,0,0,0,0,D3D11_SDK_VERSION,&swapDesc,&SwapChain,&d3dDevice,&feature_LEVEL,&d3dContext)))
{
MessageBox(hwnd,L"Failed Creating back buffer and device",L"Error",0);
}*/
#pragma endregion
#pragma region Create Render Target View
ID3D11RenderTargetView * RenderTarget ;
ID3D11Texture2D * backBuffer ;
SecureZeroMemory(&backBuffer,sizeof(ID3D11Texture2D));
SecureZeroMemory(&RenderTarget,sizeof(ID3D11RenderTargetView));
SwapChain->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&backBuffer);
d3dDevice->CreateRenderTargetView(backBuffer,NULL,&RenderTarget);
// d3dContext->OM
//Release COM
backBuffer->Release();
#pragma endregion
#pragma region Create Depth Stencil Texture
D3D11_TEXTURE2D_DESC depthDesc;
SecureZeroMemory(&depthDesc,sizeof(depthDesc)); // Allocate Memeory
depthDesc.ArraySize = 1;
//Flags
depthDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthDesc.CPUAccessFlags = 0;
depthDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; // Format
// Area
depthDesc.Height = 512;
depthDesc.Width = 512;
// Mipmap and MXAA
depthDesc.MipLevels= 1;
depthDesc.SampleDesc.Count = 4;
depthDesc.SampleDesc.Quality = multisampleQuality -1;
depthDesc.Usage = D3D11_USAGE_DEFAULT;
depthDesc.MiscFlags = 0;
// Create and initialize pointers
ID3D11Texture2D * DepthTexture = 0;
ID3D11DepthStencilView * depthView = 0;
//d3dDevice->CreateTexture2D(&depthDesc,0,&DepthTexture);
// d3dDevice->CreateDepthStencilView(DepthTexture,0,&depthView);
#pragma endregion
#pragma region Bind to Output
d3dContext->OMSetRenderTargets(1,&RenderTarget,NULL); // removed depth buffer for testing but still wont work
#pragma endregion
#pragma region Create ViewPort
D3D11_VIEWPORT viewport;
//Clear mommory
SecureZeroMemory(&viewport,sizeof(viewport));
viewport.Height = 512;
viewport.Width = 512;
viewport.MinDepth = 0;
viewport.MaxDepth = 1;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
d3dContext->RSSetViewports(1,&viewport);
#pragma endregion
TwInit(ETwGraphAPI::TW_DIRECT3D11,d3dDevice);
TwWindowSize(swapDesc.BufferDesc.Width,swapDesc.BufferDesc.Height);
time.Reset();
InitPipeline();
#pragma region Vertex Buffer Creation
CVertex vertex[3] = {
{0,0,0,Color::white},
{0.5,0,0,Color::white},
{0.25,0.5,0,Color::Red},
};
D3D11_BUFFER_DESC VbufferDesc;
D3D11_SUBRESOURCE_DATA vBufferInit;
SecureZeroMemory(&vertex,sizeof(vertex));
SecureZeroMemory(&VbufferDesc,sizeof(VbufferDesc));
SecureZeroMemory(&vBufferInit,sizeof(vBufferInit));
VbufferDesc.Usage = D3D11_USAGE_DEFAULT;
VbufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
VbufferDesc.ByteWidth = 3* sizeof(CVertex);
VbufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_FLAG::D3D11_CPU_ACCESS_READ;
VbufferDesc.MiscFlags = 0;
VbufferDesc.StructureByteStride = 0;
vBufferInit.pSysMem = vertex;
ID3D11Buffer * Vbuffer = {0};
d3dDevice->CreateBuffer(&VbufferDesc,&vBufferInit,&Vbuffer);
#pragma endregion
while(msg.message != WM_QUIT)
{
if(PeekMessage(&msg,hwnd,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}else{
// Update Sequences
// Rendering
d3dContext->ClearRenderTargetView(RenderTarget,D3DXCOLOR(0,0,300,0));
UINT stride = sizeof(CVertex);
UINT offset = 0;
d3dContext->IASetVertexBuffers(0,1,&Vbuffer,&stride,&offset);
d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY::D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
d3dContext->Draw(3,0);
SwapChain->Present(0,0);
}
}
}
return msg.wParam;
}
void InitPipeline()
{
ID3D10Blob * vBuffBlob = 0;
ID3D10Blob * pBuffBlob = 0;
//SecureZeroMemory(&vBuffBlob,sizeof(ID3D10Blob));
//SecureZeroMemory(&pBuffBlob,sizeof(ID3D10Blob));
SecureZeroMemory(&vshader,sizeof(ID3D11VertexShader));
SecureZeroMemory(&pixelShader,sizeof(ID3D11PixelShader));
HRESULT hr = D3DX11CompileFromFile(L"source.shader",0,0,"VShader","vs_4_0",0,0,0,&vBuffBlob,0,0);
D3DX11CompileFromFile(L"source.shader",0,0,"PShader","ps_4_0",0,0,0,&pBuffBlob,0,0);
if(FAILED(hr))
MessageBeep(1);
d3dDevice->CreateVertexShader(vBuffBlob->GetBufferPointer(),vBuffBlob->GetBufferSize(),NULL,&vshader);
d3dDevice->CreatePixelShader(pBuffBlob->GetBufferPointer(),pBuffBlob->GetBufferSize(),NULL,&pixelShader);
D3D11_INPUT_ELEMENT_DESC inp[] = {
{"POSITION",0,DXGI_FORMAT_R32G32B32_FLOAT,0,0,D3D11_INPUT_PER_VERTEX_DATA,0},
{"COLOR",0,DXGI_FORMAT_R32G32B32A32_FLOAT,0,12,D3D11_INPUT_PER_VERTEX_DATA,0}
};
SecureZeroMemory(inp,sizeof(inp));
ID3D11InputLayout * inputL = 0;
d3dDevice->CreateInputLayout(inp,2,vBuffBlob->GetBufferPointer(),vBuffBlob->GetBufferSize(),&inputL);
d3dContext->IASetInputLayout(inputL);
d3dContext->VSSetShader(vshader,NULL,0);
d3dContext->PSSetShader(pixelShader,0,0);
pBuffBlob->Release();
vBuffBlob->Release();
}
// Initialize and show the Window
bool InitWindowClass(HINSTANCE hinst,int shw,HWND * _hwnd,WNDCLASSEX * exClass)
{
exClass->cbSize = sizeof(WNDCLASSEX);
exClass->hCursor = LoadCursor(0,IDC_ARROW);
exClass->hInstance = hinst;
exClass->lpfnWndProc = WndProc;
exClass->lpszClassName = L"DX_Test";
exClass->lpszMenuName = L"Test";
exClass->hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
RegisterClassEx(exClass);
AdjustWindowRect(&windowWidth,WS_OVERLAPPEDWINDOW,false);
(*_hwnd) = CreateWindowEx(0,L"DX_Test",L"Test",WS_OVERLAPPEDWINDOW,500,200,windowWidth.right - windowWidth.left,windowWidth.bottom-windowWidth.top,NULL,NULL,hinst,0);
ShowWindow((*_hwnd),shw);
UpdateWindow(*_hwnd);
return true;
}
// Message Loop
LRESULT CALLBACK WndProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam)
{
.....

Answer 1

First off, you're not properly initializing the D3D11_INPUT_ELEMENT_DESC structure. You have:
D3D11_INPUT_ELEMENT_DESC inp[] = {
{"POSITION",0,DXGI_FORMAT_R32G32B32A32_FLOAT,0,0},
{"COLOR",0,DXGI_FORMAT_R32G32B32A32_FLOAT,0,12}
};
SecureZeroMemory(inp,sizeof(inp));
which partially initializes the structure then completely zeros it. That code snippet should be:
D3D11_INPUT_ELEMENT_DESC inp[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
};
which gives the full description of the input and how it's laid out in memory.
Second, I'd suggest putting this entire project aside and spending about a week reading through both of the tutorials Chuck has linked, reading as much info on MSDN as possible, and give a good read through the book by Frank D. Luna. A lot of this stuff is addressed in his book, and all of the code is available online, so the book isn't required to learn the API (though it certainly helps).
DirectX 9 was easier to get used to, as the fixed function pipeline helped to organize a lot of this extra work. However, if you used DirectX 9.0c and Shader Model 2.x/3, a lot of this code is very similar, and is now required as there is no longer a fixed function pipeline in D3D.