DirectX9 例程

#include <d3dx9.h>

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

D3DXVECTOR3 CubeLookAt[] =
{
    D3DXVECTOR3(0.0f, -30.0f, -30.0f),
    D3DXVECTOR3(0.0f, 0.0f, 0.0f),
    D3DXVECTOR3(0.0f, 1.0f, 0.0f)
};

LPDIRECT3D9             g_pD3D           = NULL; //Direct3D对象
LPDIRECT3DDEVICE9       g_pD3DDevice     = NULL; //Direct3D设备对象
LPDIRECT3DVERTEXBUFFER9 g_pVertexBuffer  = NULL; //Buffer to hold vertices

PDIRECT3DTEXTURE9       g_pTexture       = NULL; //纹理指针

LPD3DXMESH              g_pMesh          = NULL; //网格模型对象
D3DMATERIAL9*           g_pMeshMaterials = NULL; //网格模型材质
LPDIRECT3DTEXTURE9*     g_pMeshTextures  = NULL; //网格模型纹理
DWORD                   g_dwNumMaterials = 0L;   //网格模型材质数量

struct CUSTOMVERTEX//自定义的顶点格式
{
    FLOAT x, y, z; //顶点坐标
    DWORD color;   //顶点颜色
    FLOAT tu, tv;  //纹理坐标
};

//Flexible Vertex Format (FVF) 灵活顶点格式
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)

//释放对象
#define SafeRelease(pObject) if(pObject != NULL) {pObject->Release(); pObject=NULL;}

//释放对象数组
#define SafeDelete(pObjectArray) if(pObjectArray != NULL){delete[] pObjectArray;}

//键盘控制
#define KeyDown(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KeyUp(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

/**************************************************************
 * Desc: 初始化 Direct3D
 **************************************************************/

HRESULT InitialiseD3D(HWND hWnd)
{
    //First of all, create the main D3D object. If it is created successfully we 
    //should get a pointer to an IDirect3D8 interface.
    g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
    if(g_pD3D == NULL)
    {
        return E_FAIL;
    }

    //Get the current display mode
    /*D3DDISPLAYMODE d3ddm;
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
    {
        return E_FAIL;
    }*/

    //Create a structure to hold the settings for our device
    D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory(&d3dpp, sizeof(d3dpp));

    //Fill the structure. 
    //We want our program to be windowed, and set the back buffer to a format
    //that matches our current display mode
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

    //深度缓冲
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    d3dpp.EnableAutoDepthStencil = TRUE; 

    //Create a Direct3D device.
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, 
                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp,     
                                   &g_pD3DDevice)))
    {
        return E_FAIL;
    }
    
    //开启背面拣选
    //g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

    //去除灯光
    //g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

    //激活深度缓冲
    //g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

    //设置环境灯光
    g_pD3DDevice->SetRenderState(D3DRS_AMBIENT, 0xFFFFFFFF);

    return S_OK;
}

/**************************************************************
 * Desc: 初始化顶点缓冲（立方体）
 **************************************************************/

HRESULT InitVertexBuffer()
{
    VOID* pVertices;
    
    //Store each point of the cube together with it's colour
    //Make sure that the points of a polygon are specified in a clockwise direction,
    //this is because anti-clockwise faces will be culled
    //We will use a three triangle strips to render these polygons
    //(Top, Sides, Bottom).
    CUSTOMVERTEX cvVertices[] =
    { 
        //Top Face
        {-5.0f, 5.0f, -5.0f, D3DCOLOR_XRGB(0, 0, 255), 0.0f, 1.0f}, //Vertex 0 - Blue 
        {-5.0f, 5.0f, 5.0f, D3DCOLOR_XRGB(255, 0, 0), 0.0f, 0.0f}, //Vertex 1 - Red 
        {5.0f, 5.0f, -5.0f, D3DCOLOR_XRGB(255, 0, 0), 1.0f, 1.0f}, //Vertex 2 - Red 
        {5.0f, 5.0f, 5.0f, D3DCOLOR_XRGB(0, 255, 0), 1.0f, 0.0f}, //Vertex 3 - Green 

        //Face 1
        {-5.0f, -5.0f, -5.0f, D3DCOLOR_XRGB(255, 0, 0), 0.0f, 1.0f}, //Vertex 4 - Red 
        {-5.0f, 5.0f, -5.0f, D3DCOLOR_XRGB(0, 0, 255), 0.0f, 0.0f}, //Vertex 5 - Blue 
        {5.0f, -5.0f, -5.0f, D3DCOLOR_XRGB(0, 255, 0), 1.0f, 1.0f}, //Vertex 6 - Green 
        {5.0f, 5.0f, -5.0f, D3DCOLOR_XRGB(255, 0, 0), 1.0f, 0.0f}, //Vertex 7 - Red 

        //Face 2
        {5.0f, -5.0f, 5.0f, D3DCOLOR_XRGB(0, 0, 255), 0.0f, 1.0f}, //Vertex 8 - Blue 
        {5.0f, 5.0f, 5.0f, D3DCOLOR_XRGB(0, 255, 0), 0.0f, 0.0f}, //Vertex 9 - Green
        
        //Face 3
        {-5.0f, -5.0f, 5.0f, D3DCOLOR_XRGB(0, 255, 0), 1.0f, 1.0f}, //Vertex 10 - Green 
        {-5.0f, 5.0f, 5.0f, D3DCOLOR_XRGB(255, 0, 0), 1.0f, 0.0f}, //Vertex 11 - Red 

        //Face 4
        {-5.0f, -5.0f, -5.0f, D3DCOLOR_XRGB(255, 0, 0), 0.0f, 1.0f}, //Vertex 12 - Red 
        {-5.0f, 5.0f, -5.0f, D3DCOLOR_XRGB(0, 0, 255), 0.0f, 0.0f}, //Vertex 13 - Blue

        //Bottom Face
        {5.0f, -5.0f, -5.0f, D3DCOLOR_XRGB(0, 255, 0), 0.0f, 1.0f}, //Vertex 14 - Green 
        {5.0f, -5.0f, 5.0f, D3DCOLOR_XRGB(0, 0, 255), 0.0f, 0.0f}, //Vertex 15 - Blue 
        {-5.0f, -5.0f, -5.0f, D3DCOLOR_XRGB(255, 0, 0), 1.0f, 1.0f}, //Vertex 16 - Red 
        {-5.0f, -5.0f, 5.0f, D3DCOLOR_XRGB(0, 255, 0), 1.0f, 0.0f}, //Vertex 17 - Green
    };

    //Create the texture from file
    if(FAILED(D3DXCreateTextureFromFile(g_pD3DDevice, "1.bmp", &g_pTexture)))
    {
        return E_FAIL;
    }

    //Create the vertex buffer from our device.
    if(FAILED(g_pD3DDevice->CreateVertexBuffer(18 * sizeof(CUSTOMVERTEX),
                                               0, D3DFVF_CUSTOMVERTEX,
                                               D3DPOOL_DEFAULT, &g_pVertexBuffer, NULL)))
    {
        return E_FAIL;
    }


    //Get a pointer to the vertex buffer vertices and lock the vertex buffer
    if(FAILED(g_pVertexBuffer->Lock(0, sizeof(cvVertices), (void**)&pVertices, 0)))
    {
        return E_FAIL;
    }

    //Copy our stored vertices values into the vertex buffer
    memcpy(pVertices, cvVertices, sizeof(cvVertices));

    //Unlock the vertex buffer
    g_pVertexBuffer->Unlock();

    return S_OK;
}

/**************************************************************
 * Desc: 响应键盘事件
 **************************************************************/

VOID ProcInput()
{
    if(KeyDown(VK_DOWN))
    {
        CubeLookAt[0].z -= 0.2f;
        CubeLookAt[1].z -= 0.2f;
    }
    if(KeyDown(VK_UP))
    {
        CubeLookAt[0].z += 0.2f;
        CubeLookAt[1].z += 0.2f;
    }
    if(KeyDown(VK_RIGHT))
    {
        CubeLookAt[1].x += 0.2f;
    }
    if(KeyDown(VK_LEFT))
    {
        CubeLookAt[1].x -= 0.2f;
    }
}

/**************************************************************
 * Desc: 初始化网格模型
 **************************************************************/

HRESULT InitMesh()
{
    LPD3DXBUFFER pMaterialsBuffer;
    
    //从磁盘文件加载网格模型
    if(FAILED(D3DXLoadMeshFromX("SKULL.x", D3DXMESH_MANAGED, g_pD3DDevice, NULL, 
                                &pMaterialsBuffer, NULL, &g_dwNumMaterials, &g_pMesh)))
    {
        MessageBox(NULL, "Could not find corresponding mesh file", "Mesh", MB_OK);
        return E_FAIL;
    }

    //从网格模型中提取材质属性和纹理文件名
    D3DXMATERIAL* matMaterials = (D3DXMATERIAL*)pMaterialsBuffer->GetBufferPointer();
    
    //Create two arrays. One to hold the materials and other to hold the textures
    g_pMeshMaterials = new D3DMATERIAL9[g_dwNumMaterials];
    g_pMeshTextures = new LPDIRECT3DTEXTURE9[g_dwNumMaterials];

    //逐块提取网格模型材质属性和纹理文件名
    for(DWORD i = 0; i < g_dwNumMaterials; i++)
    {
        //材料属性
        g_pMeshMaterials[i] = matMaterials[i].MatD3D;

        //设置模型材料的环境光反射系数，因为模型材料本身没有设置
        g_pMeshMaterials[i].Ambient = g_pMeshMaterials[i].Diffuse;
        
        //创建纹理
        if(FAILED(D3DXCreateTextureFromFile(g_pD3DDevice,
                                            matMaterials[i].pTextureFilename,
                                            &g_pMeshTextures[i])))
        {
            g_pMeshTextures[i] = NULL;
        }

    }

    //We've finished with the material buffer, so release it
    SafeRelease(pMaterialsBuffer);
    
    return S_OK;
}

/**************************************************************
 * Desc: 渲染立方体
 **************************************************************/

void RenderCube()
{
    ProcInput();

   /****************************
    * Desc: 创建并设置世界矩阵 *
    ****************************/

    D3DXMATRIX matWorld, matWorldX, matWorldY, matWorldZ;

    //Create the transformation matrices
    D3DXMatrixRotationX(&matWorldX, timeGetTime()/400.0f);
    D3DXMatrixRotationY(&matWorldY, timeGetTime()/400.0f);
    D3DXMatrixRotationZ(&matWorldZ, timeGetTime()/400.0f);

    /*我们调用了D3DXMatrixRotationX、D3DXMatrixRotationY和D3DXMatrixRotationZ
    函数产生了3个矩阵而且分别将它们保存在了3个D3DXMATRIX结构中
    然后我们将它们相乘后形成了世界矩阵*/
    D3DXMatrixMultiply(&matWorld, &matWorldX, &matWorldY);
    D3DXMatrixMultiply(&matWorld, &matWorld, &matWorldZ);

    //我们又调用了SetTransform函数为我们的顶点应用了此变换
    g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);

   /****************************
    * Desc: 创建并设置观察矩阵 *
    ****************************/

    D3DXMATRIX matView;
    D3DXMatrixLookAtLH(&matView, &CubeLookAt[0],  //Camera Position
                                 &CubeLookAt[1],  //Look At Position
                                 &CubeLookAt[2]); //Up Direction
    g_pD3DDevice->SetTransform(D3DTS_VIEW, &matView);

   /****************************
    * Desc: 创建并设置投影矩阵 *
    ****************************/

    D3DXMATRIX matProj;
    /*我们设置摄像机的镜头：我们确定了视界为PI/4（正常）而横纵比为1
    我们还确定了前、后裁剪平面分别为1和500，这意味着范围之外的三角形将会被裁剪掉*/
    D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI/4, 1.0f, 1.0f, 500.0f);
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);

    //Set how the texture should be rendered.
    if(g_pTexture != NULL)
    {
        //A texture has been set. We don't want to blend our texture with
        //the colours of our vertices, so use D3DTOP_SELECTARG1
        g_pD3DDevice->SetTexture(0, g_pTexture);
        g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
    }
    else
    {
        //No texture has been set. So we will disable texture rendering.
        g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
    }

    //Rendering our objects
    g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(CUSTOMVERTEX));
    g_pD3DDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
    g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2); //Top
    g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 4, 8); //Sides
    g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 14, 2); //Bottom
}

/**************************************************************
 * Desc: 渲染网格模型
 **************************************************************/

DWORD RenderMesh()
{
    //创建并设置世界坐标系
    D3DXMATRIX matWorld;
    D3DXMatrixRotationY(&matWorld, timeGetTime()/1000.0f);
    g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);

    //创建并设置观察矩阵
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH(&matView, &D3DXVECTOR3(0.0f, 0.0f, -20.0f),
                                 &D3DXVECTOR3(0.0f, 0.0f, 0.0f),
                                 &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    g_pD3DDevice->SetTransform(D3DTS_VIEW, &matView);

    //创建并设置投影矩阵
    D3DXMATRIX matProj;
    D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f);
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);

    //逐块渲染网格模型
    if(g_pMesh != NULL)
    {
        for(DWORD i = 0; i < g_dwNumMaterials; i++)
        {
            g_pD3DDevice->SetMaterial(&g_pMeshMaterials[i]);
            g_pD3DDevice->SetTexture(0, g_pMeshTextures[i]);
        
            g_pMesh->DrawSubset(i);
        }

        return g_pMesh->GetNumFaces();
    }
    else
    {
        MessageBox(NULL,"Could not open mesh file", "Mesh", MB_OK);
        return 0;
    }
}

/**************************************************************
 * Desc: 渲染主场景
 **************************************************************/

void Render()
{
    if(g_pD3DDevice == NULL)
    {
        return;
    }

    //清空深度缓冲
    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

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

    //RenderCube();
    RenderMesh();

    //End the scene
    g_pD3DDevice->EndScene();
    
    //Filp the back and front buffers so that whatever has been rendered on the
    //back buffer will now be visible on screen (front buffer).
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}

/**************************************************************
 * Desc: 释放对象
 **************************************************************/

void CleanUp()
{
    SafeDelete(g_pMeshMaterials);

    if(g_pMeshTextures != NULL)
    {
        for(DWORD i = 0; i < g_dwNumMaterials; i++)
        {
            if(g_pMeshTextures[i])
            {
                SafeRelease(g_pMeshTextures[i]);
            }
        }
    }

    SafeDelete(g_pMeshTextures);
    SafeRelease(g_pMesh);
    SafeRelease(g_pTexture);
    SafeRelease(g_pVertexBuffer);
    SafeRelease(g_pD3DDevice);
    SafeRelease(g_pD3D);
}

/**************************************************************
 * Desc: 游戏循环
 **************************************************************/

void GameLoop()
{
    //Enter the game loop
    MSG msg; 
    BOOL fMessage;

    PeekMessage(&msg, NULL, 0U, 0U, PM_NOREMOVE);
    
    while(msg.message != WM_QUIT)
    {
        fMessage = PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE);

        if(fMessage)
        {
            //Process message
            TranslateMessage(&msg);//将虚拟键消息转换为字符消息
            DispatchMessage(&msg);//将转换后的消息传送给windows
        }
        else
        {
            //No message to process, so render the current scene
            Render();
        }
    }
}

/**************************************************************
 * Desc: 消息处理函数
 **************************************************************/

LRESULT WINAPI WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        break;
        case WM_KEYUP: 
            switch (wParam)
            { 
                case VK_ESCAPE:
                    //User has pressed the escape key, so quit
                    DestroyWindow(hWnd);
                    return 0;
                break;
            } 
        break;
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);//调用默认消息处理过程
}

/**************************************************************
 * Desc: WIN32入口函数
 **************************************************************/

INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, INT)
{
    //Register the window class
    /*WNDCLASSEX wc = {sizeof(WNDCLASSEX), CS_CLASSDC, WinProc, 0L, 0L,
                     GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                     "DX Project 3", NULL};*/
    WNDCLASSEX wc;

    //指定了结构的大小
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = CS_CLASSDC;
    //指定窗口类别的消息处理函数
    wc.lpfnWndProc   = WinProc;
    //指定窗口结构的额外空间
    wc.cbClsExtra    = 0L;
    wc.cbWndExtra    = 0L;
    //代表程序的实例句柄
    wc.hInstance     = GetModuleHandle(NULL);
    //图标
    wc.hIcon         = LoadIcon(NULL,MAKEINTRESOURCE(IDI_ERROR));
    //鼠标指针
    wc.hCursor       = LoadCursor(NULL,MAKEINTRESOURCE(IDC_CROSS));
    //背景
    wc.hbrBackground = NULL;
    //菜单
    wc.lpszMenuName  = NULL;
    //窗口类的名称
    wc.lpszClassName = "DX Project 3";
    //包含了窗口类的小图标句柄
    wc.hIconSm       = NULL;

    RegisterClassEx(&wc);

    //全屏模式
    /*HWND hWnd = CreateWindow("DX Project 3", "3D游戏", 
                              WS_POPUP, 0, 0, 
                              GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
                              GetDesktopWindow(), NULL, wc.hInstance, NULL);*/
    
    //窗口模式
    HWND hWnd = CreateWindow("DX Project 3", "3D游戏", 
                              WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX & ~WS_MINIMIZEBOX, 
                              50, 50, 500, 500,
                              GetDesktopWindow(), NULL, wc.hInstance, NULL);

    //Initialize Direct3D
    if(SUCCEEDED(InitialiseD3D(hWnd)))
    {
        //Show our window
        ShowWindow(hWnd, SW_SHOWDEFAULT);
        UpdateWindow(hWnd);

        //Initialize Vertex Buffer
        if(SUCCEEDED(/*InitVertexBuffer()*/InitMesh()))
        {
            //Start game running: Enter the game loop
            GameLoop();
        }
    }

    CleanUp();

    UnregisterClass("DX Project 3", wc.hInstance);

    return 0;
}