starting a project in directx

This article will give you an understanding of how to set up a maintainable project in Visual Studio for DirectX.
Firstly, you need to install the DirectX SDK and Visual Studio. I will assume you have done that. After that you will need to create an empty Windows c++ project. This will contain alot of useless things, so delete the <your solution name here>.cpp and .h files.
The files you will need to create next are:

main.cpp: This file will hold the main() function that is the entry point to your application.
main.h: This header just includes the recourses that we use.
AppProc.cpp: This will hold the implementation of our AppProc class
AppProc.h: This is the header for our class

//main.cpp
/*
Application: DirectX1
Refrences: http://www.codesampler.com/dx9src/dx9src_1.htm#dx9_initialization
Author: Ashley Smith
Modified: 21/11/06
*/

#define STRICT
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include "resource.h"

#include "AppProc.h"

// Global window handle
HWND g_hWnd = NULL;

// WindowProc definition
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Application entry point
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
	WNDCLASSEX winClass;
	MSG        uMsg;

memset(&uMsg,0,sizeof(uMsg));

winClass.lpszClassName = "MY_WINDOWS_CLASS";
	winClass.cbSize        = sizeof(WNDCLASSEX);
	winClass.style         = CS_HREDRAW | CS_VREDRAW;
	winClass.lpfnWndProc   = WindowProc;
	winClass.hInstance     = hInstance;
	winClass.hIcon	       = LoadIcon(hInstance, (LPCTSTR)IDI_DIRECTX_ICON);
    winClass.hIconSm	   = LoadIcon(hInstance, (LPCTSTR)IDI_DIRECTX_ICON);
	winClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
	winClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	winClass.lpszMenuName  = NULL;
	winClass.cbClsExtra    = 0;
	winClass.cbWndExtra    = 0;

if( !RegisterClassEx(&winClass) )
	{
		return E_FAIL;
	}

// Create window with params
	g_hWnd = CreateWindowEx( NULL, "MY_WINDOWS_CLASS", 
                             "Direct3D1",
						     WS_OVERLAPPEDWINDOW | WS_VISIBLE,
					         0, 0, 1280, 1024, NULL, NULL, hInstance, NULL );

if( g_hWnd == NULL )
	{
		return E_FAIL;
	}

ShowWindow( g_hWnd, nCmdShow );
    UpdateWindow( g_hWnd );

GameFramework::AppProc application;

application.SetFullscreen(true);
	application.SetBBSize(1280, 1024);

// Initialize the IDirectX9 COM interface
	application.InitDeviceObjects( g_hWnd );

// Message loop
	while( uMsg.message != WM_QUIT )
	{
		if( PeekMessage( &uMsg, NULL, 0, 0, PM_REMOVE ) )
		{ 
			TranslateMessage( &uMsg );
			DispatchMessage( &uMsg );
		}
        else
		{
			// Render to screen
			application.Render();
		}
	}

// Release IDirectX9 COM interfaces
	application.Shutdown();

UnregisterClass( "MY_WINDOWS_CLASS", winClass.hInstance );

return uMsg.wParam;
}

// Message loop
LRESULT CALLBACK WindowProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
	// Message loop
    switch( msg )
	{
        case WM_KEYDOWN:
		{
			switch( wParam )
			{
				case VK_ESCAPE:
					PostQuitMessage(0);
					break;
			}
		}
        break;
		case WM_CLOSE:
		{
			PostQuitMessage(0);
		}
        case WM_DESTROY:
		{
            PostQuitMessage(0);
		}
        break;
		default:
		{
			return DefWindowProc( hWnd, msg, wParam, lParam );
		}
		break;
	}
	return 0;
}

AppProc.h

AppProc.cpp

#include "AppProc.h"

using namespace GameFramework;

AppProc::AppProc(void)
{
	_bFullscreen = false;
	_bbWidth = 640;
	_bbHeight = 480;
}

HRESULT AppProc::InitDeviceObjects(HWND g_hWnd)
{
	g_pD3D = Direct3DCreate9( D3D_SDK_VERSION );

if( g_pD3D == NULL )
	{
		// TO DO: Respond to failure of Direct3DCreate9
		return E_FAIL;
	}

D3DDISPLAYMODE d3ddm;

if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
	{
		// TO DO: Respond to failure of GetAdapterDisplayMode
		return E_FAIL;
	}

HRESULT hr;

if( FAILED( hr = g_pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
												d3ddm.Format, D3DUSAGE_DEPTHSTENCIL,
												D3DRTYPE_SURFACE, D3DFMT_D16 ) ) )
	{
		if( hr == D3DERR_NOTAVAILABLE )
			// POTENTIAL PROBLEM: We need at least a 16-bit z-buffer!
			return E_FAIL;
	}

//
	// Do we support hardware vertex processing? if so, use it. 
	// If not, downgrade to software.
	//

D3DCAPS9 d3dCaps;

if( FAILED( g_pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, 
		                               D3DDEVTYPE_HAL, &d3dCaps ) ) )
	{
		// TO DO: Respond to failure of GetDeviceCaps
		return E_FAIL;
	}

DWORD dwBehaviorFlags = 0;

if( d3dCaps.VertexProcessingCaps != 0 )
	{
		dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
	} else {
		dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
	}

//
	// Everything checks out - create a simple, windowed device.
	//

D3DPRESENT_PARAMETERS d3dpp;
	memset(&d3dpp, 0, sizeof(d3dpp));

d3dpp.BackBufferFormat = d3ddm.Format;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	if(_bFullscreen)
	{
		d3dpp.Windowed = false;
		d3dpp.BackBufferWidth = _bbWidth;
		d3dpp.BackBufferHeight = _bbHeight;
	} else {
		d3dpp.Windowed = true;
	}
    d3dpp.EnableAutoDepthStencil = true;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd,
                                      dwBehaviorFlags, &d3dpp, &g_pd3dDevice ) ) )
	{
		// TO DO: Respond to failure of CreateDevice
		return E_FAIL;
	}
}

void AppProc::FrameMove(void)
{

}

void AppProc::Render(void)
{
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                         D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,1.0f), 1.0f, 0 );

g_pd3dDevice->BeginScene();

// Render geometry here...

g_pd3dDevice->EndScene();

g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

void AppProc::Shutdown(void)
{
    if( g_pd3dDevice != NULL )
	{
        g_pd3dDevice->Release();
	}

if( g_pD3D != NULL )
	{
        g_pD3D->Release();
	}
}

starting a project in directx

AppProc.h

AppProc.cpp

Please Wait...

Sending...