还会画三维立方体了

[zhulei1978]

感觉离梦想又近了一步

#include <d3d9.h>
#include <d3dx9.h>
#include <tchar.h>

#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"d3d9.lib")
#pragma comment(lib,"d3dx9.lib")

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define WINDOW_TITLE L"程序核心框架"
#define SAFE_RELEASE(p) {if(p){(p)->Release();(p)=NULL;}}

struct CUSTOMVERTEX
{
FLOAT x,y,z,rhw;
DWORD color;
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)

LPDIRECT3DDEVICE9 g_pd3dDevice=NULL;
ID3DXFont* g_pFont=NULL;
float g_FPS=0.0f;
wchar_t g_strFPS[50];
LPDIRECT3DVERTEXBUFFER9 g_pVertexBuffer=NULL;
LPDIRECT3DINDEXBUFFER9 g_pIndexBuffer=NULL;

LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
HRESULT Direct3D_Init(HWND hwnd);
HRESULT Objects_Init(HWND hwnd);
VOID Direct3D_Render(HWND hwnd);
VOID Direct3D_CleanUp();
float Get_FPS();
VOID Matrix_Set();

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX wndClass = { 0 };
wndClass.cbSize = sizeof( WNDCLASSEX ) ;
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInstance;
wndClass.hIcon=(HICON)::LoadImage(NULL,L"icon.ico",IMAGE_ICON,0,0,LR_DEFAULTSIZE|LR_LOADFROMFILE);
wndClass.hCursor = LoadCursor( NULL, IDC_ARROW );
wndClass.hbrBackground=(HBRUSH)GetStockObject(GRAY_BRUSH);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"ForTheDreamOfGameDevelop";

if( !RegisterClassEx( &wndClass ) )
return -1;

HWND hwnd = CreateWindow( L"ForTheDreamOfGameDevelop",WINDOW_TITLE,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, WINDOW_WIDTH,
WINDOW_HEIGHT, NULL, NULL, hInstance, NULL );

if(!(S_OK==Direct3D_Init(hwnd)))
{
MessageBox(hwnd,L"Direct3D初始化失败",L"消息窗口",0);
}


MoveWindow(hwnd,250,80,WINDOW_WIDTH,WINDOW_HEIGHT,true);
ShowWindow( hwnd, nShowCmd );
UpdateWindow(hwnd);

PlaySound(L"永遠の誓い.wav", NULL, SND_FILENAME | SND_ASYNC|SND_LOOP);

MSG msg = { 0 };
while( msg.message != WM_QUIT )
{
if( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
Direct3D_Render(hwnd);
}
}

UnregisterClass(L"ForTheDreamOfGameDevelop", wndClass.hInstance);
return 0;
}


LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
switch( message )
{
case WM_PAINT:
Direct3D_Render(hwnd);
ValidateRect(hwnd,NULL);
break;

case WM_KEYDOWN:
if(wParam==VK_ESCAPE)
DestroyWindow(hwnd);
break;

case WM_DESTROY:
Direct3D_CleanUp();
PostQuitMessage(0);
break;

default:
return DefWindowProc( hwnd, message, wParam, lParam );
}

return 0;
}


HRESULT Direct3D_Init(HWND hwnd)
{
LPDIRECT3D9 pD3D=NULL;
if(NULL==(pD3D=Direct3DCreate9(D3D_SDK_VERSION)))
return E_FAIL;

D3DCAPS9 caps;int vp=0;
if(FAILED(pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&caps)))
{
return E_FAIL;
}
if(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
vp=D3DCREATE_HARDWARE_VERTEXPROCESSING;
else
vp=D3DCREATE_SOFTWARE_VERTEXPROCESSING;

D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp,sizeof(d3dpp));
d3dpp.BackBufferWidth=WINDOW_WIDTH;
d3dpp.BackBufferHeight=WINDOW_HEIGHT;
d3dpp.BackBufferFormat=D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount=1;
d3dpp.MultiSampleType=D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality=0;
d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow=hwnd;
d3dpp.Windowed=true;
d3dpp.EnableAutoDepthStencil=true;
d3dpp.AutoDepthStencilFormat=D3DFMT_D24S8;
d3dpp.Flags=0;
d3dpp.FullScreen_RefreshRateInHz=0;
d3dpp.PresentationInterval=D3DPRESENT_INTERVAL_IMMEDIATE;

if(FAILED(pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,vp,&d3dpp,&g_pd3dDevice)))
return E_FAIL;

SAFE_RELEASE(pD3D);

if(!(S_OK==Objects_Init(hwnd))) return E_FAIL;

g_pd3dDevice->SetRenderState(D3DRS_LIGHTING,FALSE);
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);

return S_OK;
}

HRESULT Objects_Init(HWND hwnd)
{
if(FAILED(D3DXCreateFont(g_pd3dDevice,36,0,0,1,false,DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS,DEFAULT_QUALITY,0,_T("微软雅黑"),&g_pFont)))
return E_FAIL;
srand(timeGetTime());

if(FAILED(g_pd3dDevice->CreateVertexBuffer(8*sizeof(CUSTOMVERTEX),
0,D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT,&g_pVertexBuffer,NULL)))
{
return E_FAIL;
}

if(FAILED(g_pd3dDevice->CreateIndexBuffer(36*sizeof(WORD),0,
D3DFMT_INDEX16,D3DPOOL_DEFAULT,&g_pIndexBuffer,NULL)))
{
return E_FAIL;
}

CUSTOMVERTEX Vertices[]=
{
{ -20.0f, 20.0f, -20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ -20.0f, 20.0f, 20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ 20.0f, 20.0f, 20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ 20.0f, 20.0f, -20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ -20.0f, -20.0f, -20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ -20.0f, -20.0f, 20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ 20.0f, -20.0f, 20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
{ 20.0f, -20.0f, -20.0f, D3DCOLOR_XRGB(rand() % 256, rand() % 256, rand() % 256) },
};

VOID* pVertices;
if(FAILED(g_pVertexBuffer->Lock(0,sizeof(Vertices),(void**)&pVertices,0)))
return E_FAIL;
memcpy(pVertices,Vertices,sizeof(Vertices));
g_pVertexBuffer->Unlock();

WORD *pIndices=NULL;
g_pIndexBuffer->Lock(0,0,(void**)&pIndices,0);

pIndices[0] = 0, pIndices[1] = 1, pIndices[2] = 2;
pIndices[3] = 0, pIndices[4] = 2, pIndices[5] = 3;

pIndices[6] = 0, pIndices[7] = 3, pIndices[8] = 7;
pIndices[9] = 0, pIndices[10] = 7, pIndices[11] = 4;

pIndices[12] = 0, pIndices[13] = 4, pIndices[14] = 5;
pIndices[15] = 0, pIndices[16] = 5, pIndices[17] = 1;

pIndices[18] = 2, pIndices[19] = 6, pIndices[20] = 7;
pIndices[21] = 2, pIndices[22] = 7, pIndices[23] = 3;

pIndices[24] = 2, pIndices[25] = 5, pIndices[26] = 6;
pIndices[27] = 2, pIndices[28] = 1, pIndices[29] = 5;

pIndices[30] = 4, pIndices[31] = 6, pIndices[32] = 5;
pIndices[33] = 4, pIndices[34] = 7, pIndices[35] = 6;
g_pIndexBuffer->Unlock();

return S_OK;
}

VOID Matrix_Set()
{
D3DXMATRIX matWorld,Rx,Ry,Rz;
D3DXMatrixIdentity(&matWorld);
D3DXMatrixRotationX(&Rx,D3DX_PI*(::timeGetTime()/1000.0f));
D3DXMatrixRotationY(&Ry,D3DX_PI*(::timeGetTime()/1000.0f/2));
D3DXMatrixRotationZ(&Rz,D3DX_PI*(::timeGetTime()/1000.0f/3));
matWorld=Rx*Ry*Rz*matWorld;
g_pd3dDevice->SetTransform(D3DTS_WORLD,&matWorld);

D3DXMATRIX matView;
D3DXVECTOR3 vEye(0.0f,0.0f,-200.0f);
D3DXVECTOR3 vAt(0.0f,0.0f,0.0f);
D3DXVECTOR3 vUp(0.0f,1.0f,0.0f);
D3DXMatrixLookAtLH(&matView,&vEye,&vAt,&vUp);
g_pd3dDevice->SetTransform(D3DTS_VIEW,&matView);

D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH(&matProj,D3DX_PI/4.0f,1.0f,1.0f,1000.0f);
g_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matProj);

D3DVIEWPORT9 vp;
vp.X=0;
vp.Y=0;
vp.Width=WINDOW_WIDTH;
vp.Height=WINDOW_HEIGHT;
vp.MinZ=0.0f;
vp.MaxZ=1.0f;
g_pd3dDevice->SetViewport(&vp);
}



void Direct3D_Render(HWND hwnd)
{
g_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(255,214,158),1.0f,0);

RECT formatRect;
GetClientRect(hwnd,&formatRect);

g_pd3dDevice->BeginScene();

Matrix_Set();
if(::GetAsyncKeyState(0x31)&0x8000f)
g_pd3dDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
if(::GetAsyncKeyState(0x32)&0x8000f)
g_pd3dDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);

g_pd3dDevice->SetStreamSource(0,g_pVertexBuffer,0,sizeof(CUSTOMVERTEX));
g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
g_pd3dDevice->SetIndices(g_pIndexBuffer);
g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,8,0,12);

int charCount=swprintf_s(g_strFPS,20,_T("FPS:%0.3f"),Get_FPS());
g_pFont->DrawText(NULL,g_strFPS,charCount,&formatRect,DT_TOP|DT_RIGHT,D3DCOLOR_XRGB(255,39,136));

g_pd3dDevice->EndScene();

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

float Get_FPS()
{
static float fps=0;
static int frameCount=0;
static float currentTime=0.0f;
static float lastTime=0.0f;

frameCount++;
currentTime=timeGetTime()*0.001f;

if(currentTime-lastTime>1.0f)
{
fps=(float)frameCount/(currentTime-lastTime);
lastTime=currentTime;
frameCount=0;
}
return fps;
}

void Direct3D_CleanUp()
{
SAFE_RELEASE(g_pIndexBuffer);
SAFE_RELEASE(g_pVertexBuffer);
SAFE_RELEASE(g_pFont);
SAFE_RELEASE(g_pd3dDevice);
}