DirectX学习---顶点缓存

今天在学习DirectX时发现了几个问题：

1、灵活顶点格式（FVF)的取值到底对图像的呈现有什么影响？

2、顶点的数据格式是否可以自己设置？

3、D3DXMatrixPerspectiveFovRH 和 D3DXMatrixPerspectiveFovLH有什么区别？

先贴出我的测试代码：

/*
运行所需的库文件：d3dx9d.lib,d3d9.lib,d3dx11.lib,dxerr.lib,dxguid.lib,winmm.lib,comctl32.lib
*/

#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <D3DX10Math.h>

#define WINDOW_WIDTH 600
#define WINDOW_HEIGHT 800
#define WINDOW_CLASS_NAME TEXT("C_class")
#define SAFE_RELEASE(p) {if(p){(p)->Release();(p) = NULL;}}

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

//结构定义
struct MVertex {
    MVertex() {};
    MVertex(float x, float y, float z) {
        m_x = x; m_y = y; m_z = z;
    }
    float m_x, m_y, m_z;
    static const DWORD FVF;
};
const DWORD MVertex::FVF = D3DFVF_XYZ;

//全局声明
float time = 2.0f;
HWND g_hdc = NULL;
HINSTANCE g_hinstance = NULL;
IDirect3DDevice9* g_device = NULL;
IDirect3DVertexBuffer9* Vbuffer = NULL;
typedef LRESULT(CALLBACK* WNDPROCRET)(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

//全局函数
LRESULT CALLBACK  WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
WNDCLASSEX&       gCreateWindowsClass(HINSTANCE hInstance, LPCTSTR name, WNDPROCRET lpfnproc,UINT style = CS_HREDRAW | CS_VREDRAW);
VOID              gMessageLoop();
HRESULT           gGame_Init(HWND hwnd);
VOID              gRender(HWND hwnd);
VOID              Clean_Up(HWND hwnd);
VOID              gCreateInterface_D3D(LPDIRECT3D9& pd3d);
VOID              gGetHalinfo(LPDIRECT3D9 pd3d,int& vp);
VOID              gFullParameter(HWND hwnd,D3DPRESENT_PARAMETERS& d3dpp);
VOID              gCreateVertexBuffer(IDirect3DDevice9* pdevice);
VOID              gCreatecamera(IDirect3DDevice9* pdevice, D3DXVECTOR3& pos, D3DXVECTOR3& target, D3DXVECTOR3& up);
VOID              gTranslation(IDirect3DDevice9* pdevice);
VOID              gMydraw(float time, IDirect3DDevice9* pdevice);


int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
{
    g_hinstance = hInstance;

    WNDCLASSEX WClass = gCreateWindowsClass(hInstance, WINDOW_CLASS_NAME, WindowProc);

    if (!RegisterClassEx(&WClass))
    {
        MessageBox(0, TEXT("error"), TEXT("注册失败！"), MB_OK);
        return 0;
    }

    g_hdc = CreateWindow(WINDOW_CLASS_NAME, TEXT("CYX"), WS_OVERLAPPEDWINDOW | WS_EX_TOPMOST,0,0,WINDOW_WIDTH,WINDOW_HEIGHT,0,0,hInstance,0);
    if (!g_hdc)
    {
        MessageBox(0, TEXT("error"), TEXT("窗口创建失败！"), MB_OK);
        return 0;
    }

    ShowWindow(g_hdc, nShowCmd);
    UpdateWindow(g_hdc);

    if (FAILED(gGame_Init(g_hdc))) {
        MessageBox(0, TEXT("error"), TEXT("游戏初始化失败！"), MB_OK);
        return 0;
    }
    
    gMessageLoop();

    UnregisterClass(WINDOW_CLASS_NAME, hInstance);
    return 0;
}

//函数定义
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
    case WM_PAINT:
        BeginPaint(hwnd, NULL);
        gRender(hwnd);
        //ValidateRect(hwnd, NULL);//这个函数还不是很清楚
        EndPaint(hwnd, NULL);
        break;
    case WM_DESTROY:
        Clean_Up(hwnd);
        PostQuitMessage(0);
        break;
    case WM_KEYDOWN:
        switch (wParam) {
        case VK_ESCAPE:
            DestroyWindow(hwnd);
            break;
        case VK_UP:
            time += 5.0f;
            break;
        case VK_DOWN:
            time -= 5.0f;
            break;
        default:break;
        }
    default:
        break;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

WNDCLASSEX& gCreateWindowsClass(HINSTANCE hInstance,LPCTSTR name, WNDPROCRET lpfnproc, UINT style /* = CS_HREDRAW | CS_VREDRAW */) {

    static WNDCLASSEX Mywindowclass;
    Mywindowclass.cbSize = sizeof(Mywindowclass);
    Mywindowclass.cbClsExtra = 0;
    Mywindowclass.cbWndExtra = 0;
    Mywindowclass.lpfnWndProc = lpfnproc;
    Mywindowclass.hInstance = hInstance;
    Mywindowclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    Mywindowclass.hCursor = LoadCursor(0, IDC_ARROW);
    Mywindowclass.hIconSm = NULL;
    Mywindowclass.hIcon = NULL;
    Mywindowclass.lpszClassName = WINDOW_CLASS_NAME;
    Mywindowclass.lpszMenuName = NULL;
    Mywindowclass.style = style;

    return Mywindowclass;
}

VOID gMessageLoop() {
    MSG mmsg = { 0 };
    while (mmsg.message != WM_QUIT)
    {
        if (PeekMessage(&mmsg, 0, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&mmsg);
            DispatchMessage(&mmsg);
        }
        else
        {
            gRender(g_hdc);
        }
    }
}

HRESULT gGame_Init(HWND hwnd) {
    LPDIRECT3D9 pd3d = NULL;
    gCreateInterface_D3D(pd3d);

    int vp = 0;
    gGetHalinfo(pd3d,vp);

    D3DPRESENT_PARAMETERS d3dpp;
    gFullParameter(hwnd, d3dpp);

    if (FAILED(pd3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, vp, &d3dpp, &g_device)))
    {
        MessageBox(0, TEXT("error"), TEXT("设备创建失败！"), MB_OK);
        return E_FAIL;
    }

    SAFE_RELEASE(pd3d);

    //创建定点缓存
    gCreateVertexBuffer(g_device);

    //设置摄像机
    D3DXVECTOR3 pos(.0f, 5.0f, 10.0f);
    D3DXVECTOR3 tar(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
    gCreatecamera(g_device,pos,tar,up);

    //变换
    gTranslation(g_device);

    return S_OK;
}

VOID gRender(HWND hwnd) {
    gMydraw(time, g_device);
}

VOID Clean_Up(HWND hwnd) {
    SAFE_RELEASE(g_device);
    SAFE_RELEASE(Vbuffer);
}

VOID gCreateInterface_D3D(LPDIRECT3D9& pd3d) {
    if (!(pd3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        MessageBox(0, TEXT("error"), TEXT("接口创建失败！"), MB_OK);
        return;
    }
}

VOID gGetHalinfo(LPDIRECT3D9 pd3d,int& vp) {
    D3DCAPS9 caps;
    if (FAILED(pd3d->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps)))
    {
        MessageBox(0, TEXT("error"), TEXT("获取设备信息失败！"), MB_OK);
        return;
    }
    if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
    {
        vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    }
    else
        vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}

VOID gFullParameter(HWND hwnd,D3DPRESENT_PARAMETERS& d3dpp) {
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.BackBufferWidth = WINDOW_WIDTH;
    d3dpp.BackBufferHeight = WINDOW_HEIGHT;
    d3dpp.BackBufferCount = 1;
    d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.Flags = 0;
    d3dpp.hDeviceWindow = hwnd;
    d3dpp.FullScreen_RefreshRateInHz = 0;
    d3dpp.MultiSampleQuality = 0;
    d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.Windowed = TRUE;
    d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;//该参数是干什么的？？
}

VOID gCreateVertexBuffer(IDirect3DDevice9* pdevice) {
    if (FAILED(pdevice->CreateVertexBuffer(
        24 * sizeof(MVertex),
        0,
        MVertex::FVF,
        D3DPOOL_MANAGED,
        &Vbuffer,
        0
    )))
    {
        MessageBox(0, TEXT("定点缓存创建失败！"), TEXT("error"), MB_OK);
        return;
    }

    //填充定点缓存
    MVertex* v = NULL;
    Vbuffer->Lock(0, 0, (VOID**)&v, 0);

    v[0] = MVertex(0.0f, 1.4f, 0.0f);     v[6] = MVertex(0.0f,1.4f, 0.0f);
    v[1] = MVertex(-1.0f, 0.0f, -1.0f);   v[7] = MVertex(1.0f, 0.0f, 1.0f);
    v[2] = MVertex(-1.0f, 0.0f, 1.0f);    v[8] = MVertex(1.0f, 0.0f, -1.0f);

    v[3] = MVertex(0.0f, 1.4f, 0.0f);     v[9] = MVertex(0.0f, 1.4f, 0.0f);
    v[4] = MVertex(-1.0f, 0.0f, 1.0f);    v[10] = MVertex(1.0f, 0.0f, -1.0f);
    v[5] = MVertex(1.0f, 0.0f, 1.0f);     v[11] = MVertex(-1.0f, 0.0f, -1.0f);

    v[12] = MVertex(0.0f, -1.4f, 0.0f);   v[13] = MVertex(-1.0f, 0.0f, -1.0f);
    v[14] = MVertex(1.0f, 0.0f, -1.0f);   v[15] = MVertex(0.0f, -1.4f, 0.0f);
    v[16] = MVertex(1.0f, 0.0f, -1.0f);   v[17] = MVertex(1.0f, 0.0f, 1.0f);

    v[18] = MVertex(0.0f, -1.4f, 0.0f);   v[19] = MVertex(1.0f, 0.0f, 1.0f);
    v[20] = MVertex(-1.0f, 0.0f, 1.0f);   v[21] = MVertex(0.0f, -1.4f, 0.0f);
    v[22] = MVertex(-1.0f, 0.0f, 1.0f);   v[23] = MVertex(-1.0f, 0.0f, -1.0f);

    Vbuffer->Unlock();
}

VOID gCreatecamera(IDirect3DDevice9* pdevice, D3DXVECTOR3& pos, D3DXVECTOR3& target, D3DXVECTOR3& up) {
    D3DXMATRIX V;
    D3DXMatrixLookAtLH(&V, &pos, &target, &up);
    pdevice->SetTransform(D3DTS_VIEW, &V);
}

VOID gTranslation(IDirect3DDevice9* pdevice) {
    //投影变换
    D3DXMATRIX proj;
    //居然还有D3DMatrixPerspectiveFovRH()
    D3DXMatrixPerspectiveFovLH(
        &proj,
        D3DX_PI*0.5f,
        (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT,
        1.0f,
        1000.0f
    );
    pdevice->SetTransform(D3DTS_PROJECTION, &proj);

    //设置线型
    pdevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
    //打开光照
    //pdevice->SetRenderState(D3DRS_LIGHTING, FALSE);
}

VOID gMydraw(float time, IDirect3DDevice9* pdevice) {
    if (pdevice)
    {
        D3DXMATRIX Rx;
        static float y = 0.0f;
        D3DXMatrixRotationX(&Rx, y);
        y += time*0.002;
        if (y > 6.28f)
            y = 0.0f;
        pdevice->SetTransform(D3DTS_WORLD, &Rx);

        pdevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(230, 230, 230), 1.0f, 0);
        pdevice->BeginScene();
        pdevice->SetStreamSource(0, Vbuffer, 0,sizeof(MVertex));
        pdevice->SetFVF(MVertex::FVF);
        pdevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 8);
        pdevice->EndScene();
        pdevice->Present(0, 0, 0, 0);
    }
}

现在我们来解决问题吧、

一、灵活顶点格式（FVF)的取值到底对图像的呈现有什么影响？

首先，常用的灵活顶点格式的取值及含义如下：

D3DFVF_XYZ——顶点的三维坐标（分别代表X,Y,Z坐标），表示有位置，而且需要进行矩阵变换（世界，投影，视口，取景）和设置摄像机位置才能在屏幕上显示；
D3DFVF_XYZRHW——即平时所说rhw，它说明顶点有位置，而且经过了矩阵变换，不用再由Direct3D对它进行变换，通常用于做UI（用户界面）；
D3DFVF_DIFFUSE——表示顶点格式中有漫反射颜色（这涉及到顶点数据格式的设置），同时，必须开启了光照才能看到设置的颜色，否则是本色（一般是白色）的；
D3DFVF_NORMAL——表示顶点有法线向量；
D3DFVF_TEX*——表示顶点有纹理坐标，*可以是1至8，表示有多少套纹理坐标

举例来说，上述测试代码中，我的想法是将顶点格式设置为包含三个原始坐标的类，所以在FVF设置时我就将其设置为D3DFF_XYZ,同时，在后续绘制于屏幕之前，我将

我的坐标进行了投影变换同时设置了摄像机的位置，如果将摄像机注释掉，则在屏幕上看不到任何东西。

*注意：

1、D3DFVF_XYZ默认的用户区中心坐标是（0，0），而D3DFVF_XYZRHW是左上角为（0，0）
用D3DFVF_XYZ默认的为非光照的，而D3DFVF_XYZRHW是高洛德光照。

二、顶点的数据格式是否可以自己设置？

答案当然是一定的，不过一般要根据自己的FVF需求去设置，比如，如果你使用D3DFVF_XYZ(D3DFVF_XYZRHW) | D3DFVF_DIFFUSE | D3DFVF_NORMAL,那么你的顶点数据结构

就应该有三种内容：坐标，颜色，法向量。对于我而言，我习惯于将FVF也定义到顶点数据结构中，这比较方便、

三、D3DXMatrixPerspectiveFovRH 和 D3DXMatrixPerspectiveFovLH有什么区别？

前者是创建右手坐标透视投影矩阵，而后者是创建左手坐标透视投影矩阵。回顾一下左手坐标与右手坐标：

左手坐标：伸出左手，让拇指和食指成“L”形，大拇指向右，食指向上。其余的手指指向前方。这样就建立了一个左手坐标系。拇指、食指和其余手指分别代表x，y，z轴的正方向。判断方法：在空间直角坐标系中，让左手拇指指向x轴的正方向，食指指向y轴的正方向，如果中指能指向z轴的正方向，则称这个坐标系为左手直角坐标系．反之则是右手直角坐标系。

右手坐标：右手坐标系在我们以前初中高中学几何的时候也经常用到。在三维坐标系中，Z轴的正轴方向是根据右手定则确定的。右手定则也决定三维空间中任一坐标轴的正旋转方向。要标注X、Y和Z轴的正轴方向，就将右手背对着屏幕放置，拇指即指向X轴的正方向。伸出食指和中指，如右图所示，食指指向Y轴的正方向，中指所指示的方向即是Z轴的正方向。要确定轴的正旋转方向，如下图所示，用右手的大拇指指向轴的正方向，弯曲手指。那么手指所指示的方向即是轴的正旋转方向。