main.cpp

<B>很多DirectX 9.0游戏编程源码例子</B>

//-----------------------------------------------------------------------------
// Name: D3D_AnimationEditor
//
// Description: Example code showing how playback animations.
//
// File Function: Main body of the program (main.cpp)
//
// Code: 
//		Copyright (c) 2003 LostLogic Corporation. All rights reserved.
//
// Libraries Required:
//		d3d9.lib dxguid.lib d3dx9dt.lib d3dxof.lib comctl32.lib winmm.lib
//
// Local Files Required:
//		main.cpp
//		main.h
//		Object3DClass.cpp
//		Object3DClass.h
//		ExceptionClass.cpp
//		ExceptionClass.h
//		C3DAnimation.cpp
//		C3DAnimation.h
//
// DX Files: 
//		Copyright (c) 1997-2001 Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include "main.h"

//--------------------------------------------------------------------------------------
//
// Main windows function, ie main()
//
//--------------------------------------------------------------------------------------
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
	HWND		hWnd;
	MSG			msg;
	WNDCLASSEX	wndclass;
	RECT		rcWindowClient;
	DWORD		dwInputTimer = 0;
	int			iResult = 0;
		
    // Set up window class
	wndclass.cbSize			= sizeof(wndclass);
	wndclass.style			= CS_HREDRAW | CS_VREDRAW;
	wndclass.lpfnWndProc	= fnMessageProcessor;
	wndclass.cbClsExtra		= 0;
	wndclass.cbWndExtra		= 0;
	wndclass.hInstance		= hInstance;
	wndclass.hIcon			= LoadIcon( NULL, IDI_APPLICATION );
	wndclass.hCursor		= LoadCursor( NULL, IDC_ARROW );
	wndclass.hbrBackground	= (HBRUSH) GetStockObject (WHITE_BRUSH);
	wndclass.lpszMenuName	= NULL;
	wndclass.lpszClassName	= "D3D_AnimationPlayback";	// Registered Class Name
	wndclass.hIconSm		= LoadIcon( NULL, IDI_APPLICATION );

	// Register the window class
	if( RegisterClassEx( &wndclass ) == NULL ) 
	{
		// The program failed, exit
		exit(1);
	}

	// Create the window
	hWnd = CreateWindowEx(	WS_EX_OVERLAPPEDWINDOW,
							"D3D_AnimationPlayback",		// Class Name
							"D3D_AnimationPlayback",		// Name Displayed on Title Bar
							WS_OVERLAPPEDWINDOW,
							0,
							0,
							g_iWindowWidth,
							g_iWindowHeight,
							NULL,
							NULL,
							hInstance,
							NULL );

	// Store window handle globally for access later
	g_hWnd = hWnd;
	
	// Display the window
	ShowWindow( hWnd, iCmdShow );

	// Figure out the client work area
	GetClientRect( hWnd, &rcWindowClient );

	// Calculate the rendering offsets based on the client size
	g_iXOffset = (g_iWindowWidth-(rcWindowClient.right-rcWindowClient.left));
	g_iYOffset = (g_iWindowHeight-(rcWindowClient.bottom-rcWindowClient.top));

	// Resize the window to be truely the resolution desired
	SetWindowPos( 
				hWnd, 
				NULL, 
				0,								// X-Pos
				0,								// Y-Pos
				g_iWindowWidth + g_iXOffset,	// Width
				g_iWindowHeight + g_iYOffset,	// Height
				NULL);

	// Clear out message structure
	ZeroMemory( &msg, sizeof(msg) );

	// Initialize Direct3D
    if( SUCCEEDED( InitD3D( hWnd ) ) ) {
			
		// Initialize lights
		vCreateLights();

		// Setup the animation
		animTest.vSet3DDevice( g_pd3dDevice );
		animTest.vLoad( "RobotIdle" );

        // Enter the message loop
        while( msg.message!=WM_QUIT ) {
            if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) ) {
                TranslateMessage( &msg );
                DispatchMessage( &msg );
            }
            else {
				// Render the scene
				vRender();
			}
        }
    }
	// Clean up everything and exit the app
    vCleanup();
    UnregisterClass( "D3D_AnimationPlayback", wndclass.hInstance );
    return 0;
}

//--------------------------------------------------------------------------------------
//
// Windows message processor
//
//--------------------------------------------------------------------------------------
LRESULT WINAPI fnMessageProcessor( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
		case WM_DESTROY:
            PostQuitMessage( 0 );
            return 0;

		default:
			break;
    }
    return DefWindowProc( hWnd, msg, wParam, lParam );
}

//--------------------------------------------------------------------------------------
//
// Function to initialize Direct 3D
//
//--------------------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
	D3DPRESENT_PARAMETERS	d3dpp;
	D3DXMATRIX				matproj, matview;
	D3DDISPLAYMODE			d3ddm;

    // Create the D3D object
    if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
        return E_FAIL;
	
	// Get the current desktop display mode, so we can set up a back
	// buffer of the same format
    if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
        return E_FAIL;
	
    // Setup the back buffer and swap format
	ZeroMemory( &d3dpp, sizeof(d3dpp) );
	d3dpp.Windowed					= TRUE;
	d3dpp.SwapEffect				= D3DSWAPEFFECT_DISCARD;
	d3dpp.BackBufferFormat			= d3ddm.Format;
	d3dpp.EnableAutoDepthStencil	= true;
	//
	// ** CHANGE THIS IS YOUR DISPLAY FAILS TO INITIALIZE **
	// Try D3DFMT_D16 or D3DFMT_D32
	// 
	d3dpp.AutoDepthStencilFormat	= D3DFMT_D16;

    // Create the D3DDevice
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }
	
	//---------------------------------------------
	//     Setup 3D View and Rendering States
	//---------------------------------------------
	
	// Set up view area
	g_vecCameraOrigin = D3DXVECTOR3( 0.0f, 10.0, -50.0 );
	g_vecCameraTarget = D3DXVECTOR3( 0.0, 15.0, 0.0 );
	vSetupView( g_vecCameraOrigin, g_vecCameraTarget );

	// Setup Projection 
	D3DXMatrixPerspectiveFovLH( &matproj, D3DX_PI/4, 1.0f, 1.0f, 1000.0f );

	// Tell the device to use the above matrix for projection
	g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matproj );

	// Set render states
	g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
	g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, TRUE );
	g_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );

    return S_OK;
}

//--------------------------------------------------------------------------------------
//
// Function to cleanup allocated objects
//
//--------------------------------------------------------------------------------------
void vCleanup( void )
{
	// Free the 3D device
    if( g_pd3dDevice != NULL ) 
        g_pd3dDevice->Release();

	// Free Direct 3D
    if( g_pD3D != NULL )       
        g_pD3D->Release();
}

//--------------------------------------------------------------------------------------
//
// Function to draw the 3D scene
//
//--------------------------------------------------------------------------------------
void vRender( void )
{
	int		iCFrame;

	// Clear the backbuffer to a blue color
	g_pd3dDevice->Clear(	0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 
							D3DCOLOR_RGBA( 200, 250, 255, 255 ), 1.0f, 0 );

	// Begin the scene
	g_pd3dDevice->BeginScene();

	// Set default material
	g_pd3dDevice->SetMaterial( &g_mtrlDefault );

	//
	// Render the 3d object( s )
	//
	if( animTest.m_iNumFrames && animTest.m_iNumObjects ) {
		for( int i = 0; i < animTest.m_iNumObjects; i++ ) {

			// Set current frame
			iCFrame = animTest.m_iCurFrame;
			
			// Render the object using the frame information
			// stored in the animation object.
			animTest.m_objObject[ i ]->vDisplayXYZ( 
				animTest.m_keyFrames[ i ][iCFrame]->m_vecTrans.x,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecTrans.y,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecTrans.z,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecRot.x,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecRot.y,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecRot.z,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecScale.x,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecScale.y,
				animTest.m_keyFrames[ i ][iCFrame]->m_vecScale.z );

			// Animate the object
			animTest.m_lCurTime++;
			// Advance to next frame
			if( animTest.m_lCurTime >= animTest.m_keyFrames[ i ][iCFrame]->m_lTimeDelay ) {
				animTest.m_iCurFrame++;
				animTest.m_lCurTime = 0;
				// Reset frame to zero
				if( animTest.m_iCurFrame >= animTest.m_iNumFrames ) {
					animTest.m_iCurFrame = 0;
				}
			}
		}
	}

	// End the scene
	g_pd3dDevice->EndScene();

	// Present the backbuffer contents to the display
	g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

//--------------------------------------------------------------------------------------
//
// Creates lights for the 3D scene
//
//--------------------------------------------------------------------------------------
void vCreateLights(void)
{
	D3DLIGHT9		d3dLight;

	// Initialize the default scene material
    ZeroMemory( &g_mtrlDefault, sizeof(D3DMATERIAL9) );
    g_mtrlDefault.Ambient.r = 1.0f;
	g_mtrlDefault.Ambient.g = 1.0f;
	g_mtrlDefault.Ambient.b = 1.0f;
	g_mtrlDefault.Ambient.a = 1.0f;
	g_mtrlDefault.Diffuse.r = 1.0f;
	g_mtrlDefault.Diffuse.g = 1.0f;
	g_mtrlDefault.Diffuse.b = 1.0f;
	g_mtrlDefault.Diffuse.a = 1.0f;
	g_pd3dDevice->SetMaterial( &g_mtrlDefault );
	
	// Clear out light structure
	ZeroMemory(&d3dLight, sizeof(D3DLIGHT9));
	d3dLight.Type = D3DLIGHT_POINT;
	d3dLight.Diffuse.r  = 1.0f;
	d3dLight.Diffuse.g  = 1.0f;
	d3dLight.Diffuse.b  = 1.0f;
	d3dLight.Position.x = 0.0f;
	d3dLight.Position.y = 30.0f;
	d3dLight.Position.z = -100.0f;
	d3dLight.Attenuation0 = 1.0f; 
	d3dLight.Attenuation1 = 0.0025f;
	d3dLight.Range      = 1000.0f;
	// Set the active light
    g_pd3dDevice->SetLight( 0, &d3dLight );
	// Enable the light
    g_pd3dDevice->LightEnable( 0, TRUE );
	// Set ambient light
	g_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x00606060 );
}

//--------------------------------------------------------------------------------------
//
// Sets up the view matrix for the 3D scene.  This puts the 
// camera in its proper place
//
//--------------------------------------------------------------------------------------
void vSetupView( D3DXVECTOR3 origin, D3DXVECTOR3 target )
{
	D3DXMATRIX	matview;

	// Setup Camera View
	D3DXMatrixLookAtLH( &matview, 
						&origin, 
						&target, 
						&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );

	// Tell the device to use the camera view for the viewport
	g_pd3dDevice->SetTransform( D3DTS_VIEW, &matview );
}