C++

Forum

 
D3D11DeviceContext::DrawIndexed Failed

Clearner1 (40)
my program is Directx Program that draws a container cube within it smaller cubes....these smaller cubes fall by time i hope you understand what i mean...
The program isn't complete yet ...it should draws the container only ....but it draws nothing ...only the background color is visible....i cannot post the complete code
(it is too much) i only included what i think is needed ...

this is the routines that initialize the program
1
2
3
4
 
bool Game::init(HINSTANCE hinst,HWND _hw){
	Directx11 ::init(hinst , _hw);
	return LoadContent();
}

Direx11::init()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
bool Directx11::init(HINSTANCE hinst,HWND hw){
	_hinst=hinst;_hwnd=hw;
	RECT rc;
	GetClientRect(_hwnd,&rc);
	height= rc.bottom - rc.top;
	width = rc.right - rc.left;
	UINT flags=0;
#ifdef _DEBUG
	flags |=D3D11_CREATE_DEVICE_DEBUG;
#endif
	HR(D3D11CreateDevice(0,_driverType,0,flags,0,0,D3D11_SDK_VERSION,&d3dDevice,&_featureLevel,&d3dDeviceContext));
	if (d3dDevice == 0 || d3dDeviceContext == 0)
		return 0;
	DXGI_SWAP_CHAIN_DESC sdesc;
	ZeroMemory(&sdesc,sizeof(DXGI_SWAP_CHAIN_DESC));
	sdesc.Windowed=true;
	sdesc.BufferCount=1;
	sdesc.BufferDesc.Format=DXGI_FORMAT_R8G8B8A8_UNORM;
	sdesc.BufferDesc.Height=height;
	sdesc.BufferDesc.Width=width;
	sdesc.BufferDesc.Scaling=DXGI_MODE_SCALING_UNSPECIFIED;
	sdesc.BufferDesc.ScanlineOrdering=DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
	sdesc.OutputWindow=_hwnd;
	sdesc.BufferDesc.RefreshRate.Denominator=1;
	sdesc.BufferDesc.RefreshRate.Numerator=60;
	sdesc.Flags=0;
	sdesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	if (m4xMsaaEnable)
	{
		sdesc.SampleDesc.Count=4;
		sdesc.SampleDesc.Quality=m4xMsaaQuality-1;
	}
	else
	{
		sdesc.SampleDesc.Count=1;
		sdesc.SampleDesc.Quality=0;
	}
	IDXGIDevice *Device=0;
	HR(d3dDevice->QueryInterface(__uuidof(IDXGIDevice),reinterpret_cast <void**> (&Device)));
	IDXGIAdapter*Ad=0;
	HR(Device->GetParent(__uuidof(IDXGIAdapter),reinterpret_cast <void**> (&Ad)));
	IDXGIFactory* fac=0;
	HR(Ad->GetParent(__uuidof(IDXGIFactory),reinterpret_cast <void**> (&fac)));
	fac->CreateSwapChain(d3dDevice,&sdesc,&swapchain);
	ReleaseCOM(Device);
	ReleaseCOM(Ad);
	ReleaseCOM(fac);
	ID3D11Texture2D *back = 0;
	HR(swapchain->GetBuffer(0,__uuidof(ID3D11Texture2D),reinterpret_cast <void**> (&back)));
	HR(d3dDevice->CreateRenderTargetView(back,0,&RenderTarget));
	D3D11_TEXTURE2D_DESC Tdesc;
	ZeroMemory(&Tdesc,sizeof(D3D11_TEXTURE2D_DESC));
	Tdesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
	Tdesc.ArraySize = 1;
	Tdesc.Format= DXGI_FORMAT_D24_UNORM_S8_UINT;
	Tdesc.Height= height;
	Tdesc.Width = width;
	Tdesc.Usage = D3D11_USAGE_DEFAULT;
	Tdesc.MipLevels=1;
	if (m4xMsaaEnable)
	{
		Tdesc.SampleDesc.Count=4;
		Tdesc.SampleDesc.Quality=m4xMsaaQuality-1;
	}
	else
	{
		Tdesc.SampleDesc.Count=1;
		Tdesc.SampleDesc.Quality=0;
	}
	HR(d3dDevice->CreateTexture2D(&Tdesc,0,&depthview));
	HR(d3dDevice->CreateDepthStencilView(depthview,0,&depth));
	d3dDeviceContext->OMSetRenderTargets(1,&RenderTarget,depth);
	D3D11_VIEWPORT vp;
	vp.TopLeftX=0.0f;
	vp.TopLeftY=0.0f;
	vp.Width = static_cast <float> (width);
	vp.Height= static_cast <float> (height);
	vp.MinDepth = 0.0f;
	vp.MaxDepth = 1.0f;
	d3dDeviceContext -> RSSetViewports(1,&vp);
	return true;


LoadContent() Loads The Effect File No proplem in loading the effect file

this is the routine that creates the container and the smaller cubes meshes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
bool Game::GeoBuild(){
	CreateInputLayout();
	CreateRasterizerState();
	CreateBox(30.0,30.0,30.0,Build);
	CreateBox(3.0,3.0,3.0,Piese);
	SetBuild(&B);

	build_vers_index = 0;
	build_vers_count= Build.vertices.size();
	build_ind_index= 0;
	build_ind_count=Build.indices.size();

	piese_vers_index = build_vers_count;
	piese_vers_count= Piese.vertices.size();
	piese_ind_index= build_ind_count;
	piese_ind_count=Piese.indices.size();

	UINT k=0;
	std::vector <Vertex> Vers(piese_vers_count + build_vers_count);
	for (UINT i = 0; i < build_vers_count; i++,k++)
	{
		XMStoreFloat4(&Build.vertices[i].Color,(XMVECTOR)Colors::Red);
		Vers[k]=Build.vertices[i];
	}
	for (UINT i = 0; i < piese_vers_count; i++ , k++)
	{
		XMStoreFloat4(&Piese.vertices[i].Color,(XMVECTOR)Colors::Green);
		Vers[k]=Piese.vertices[i];
	}
	

	D3D11_BUFFER_DESC desc;
	desc.BindFlags=D3D11_BIND_VERTEX_BUFFER;
	desc.ByteWidth=sizeof(Vertex) * (piese_vers_count + build_vers_count);
	desc.CPUAccessFlags=0;
	desc.MiscFlags=0;
	desc.Usage=D3D11_USAGE_IMMUTABLE;

	D3D11_SUBRESOURCE_DATA Data;
	ZeroMemory(&Data,sizeof(D3D11_SUBRESOURCE_DATA));
	Data.pSysMem=&Vers[0];

	HR(d3dDevice->CreateBuffer(&desc,&Data,&vertices));
	std::vector<UINT> inds(piese_ind_count + build_ind_count);
	k=0;
	for (UINT i = 0; i < build_ind_count; i++,k++)
	{
		inds[k]=Build.indices[i];
	}
	for (UINT i = 0; i < piese_ind_count; i++ , k++)
	{
		inds[k]=Piese.indices[i];
	}
	
	desc.BindFlags=D3D11_BIND_INDEX_BUFFER;
	desc.ByteWidth=sizeof(UINT) * inds.size();
	desc.CPUAccessFlags=0;
	desc.MiscFlags=0;
	desc.Usage=D3D11_USAGE_IMMUTABLE;
	ZeroMemory(&Data,sizeof(D3D11_SUBRESOURCE_DATA));
	Data.pSysMem=&inds[0];
	HR(d3dDevice->CreateBuffer(&desc,&Data,&indices));

	return true;
}

SetBuild() Prepare the matrices inside the container for the smaller cubes ....i didnt program it to draw the smaller cubes yet



and this the function that draws the scene
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
void Game::Render(){
	d3dDeviceContext->ClearRenderTargetView(RenderTarget,reinterpret_cast <const float*> (&Colors::LightSteelBlue));
	d3dDeviceContext->ClearDepthStencilView(depth,D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,1.0f,0);

	d3dDeviceContext-> IASetInputLayout(_layout);
	d3dDeviceContext-> IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	d3dDeviceContext->IASetIndexBuffer(indices,DXGI_FORMAT_R32_UINT,0);
	UINT strides=sizeof(Vertex),off=0;
	d3dDeviceContext->IASetVertexBuffers(0,1,&vertices,&strides,&off);
	
	D3DX11_TECHNIQUE_DESC des;
	Tech->GetDesc(&des);Floor * Lookup;
	std::vector<XMFLOAT4X4> filled;
	XMMATRIX V=XMLoadFloat4x4(&View),P = XMLoadFloat4x4(&Proj);
	XMMATRIX vp = V * P;XMMATRIX wvp;XMFLOAT4X4 fwvp;
	for (UINT i = 0; i < des.Passes; i++)
	{
		d3dDeviceContext->RSSetState(BuildRast);
		wvp = XMLoadFloat4x4(&(B.Memory[0].Pieces[0])) * vp;
		XMStoreFloat4x4(&fwvp,wvp);
		HR(ShadeMat->SetMatrix(reinterpret_cast<float*> ( &wvp)));
		HR(Tech->GetPassByIndex(i)->Apply(0,d3dDeviceContext));
		d3dDeviceContext->DrawIndexed(build_ind_count,build_ind_index,build_vers_index);

		d3dDeviceContext->RSSetState(PieseRast);
		UINT r1=B.GetSize(),r2=filled.size();
		for (UINT j = 0; j < r1; j++)
		{
			Lookup = &B.Memory[j];
			for (UINT r = 0; r < Lookup->filledindeces.size(); r++)
			{
				filled.push_back(Lookup->Pieces[Lookup->filledindeces[r]]);
			}
		}
		for (UINT j = 0; j < r2; j++)
		{
			ShadeMat->SetMatrix( reinterpret_cast<const float*> (&filled[i]));
			Tech->GetPassByIndex(i)->Apply(0,d3dDeviceContext);
			d3dDeviceContext->DrawIndexed(piese_ind_count,piese_ind_index,piese_vers_index);
		}
	}
	HR(swapchain->Present(0,0));
}


thanks for reading
Last edited on
Topic archived. No new replies allowed.