Direct基础学习系列3 绘制+实例

3.1.1顶点缓存 索引缓存

放置在显存中能够加快绘制速度

创建顶点缓存

HRESULT CreateVertexBuffer(
  UINT Length,    //为缓存分配的字节数
  DWORD Usage,    //缓存附加属性，可为0
  DWORD FVF,      //顶点格式
  D3DPOOL Pool,   //缓存的内存池
  IDirect3DVertexBuffer9** ppVertexBuffer, //返回的结构
  HANDLE* pSharedHandle  //不用 设置为0
);

创建索引缓存

HRESULT CreateIndexBuffer(
  UINT Length,
  DWORD Usage,
  D3DFORMAT Format,
  D3DPOOL Pool,
  IDirect3DIndexBuffer9** ppIndexBuffer,
  HANDLE* pSharedHandle
);

Usage ！= D3DUSAGE_DYNAMIC 放置在静态缓存中，适合处理运行中不需要修改的数据

Usage = D3DUSAGE_DYNAMIC 放置在动态缓存，适合频繁更新内容，如粒子系统，动态缓存放置在内存AGP区域，可以很快的被更新

3.1.2访问数据

HRESULT Lock( 

UINT OffsetToLock,   //缓存中的起始点
UINT SizeToLock,   //需要锁定的数目

VOID ** ppbData,     //返回的被锁定的缓存区起始位置
DWORD Flags          //锁定方式：

);

BOOL Unlock();

3.1.3获得顶点缓存信息

typedef struct D3DVERTEXBUFFER_DESC {
    D3DFORMAT Format;
    D3DRESOURCETYPE Type;
    DWORD Usage;
    D3DPOOL Pool;
    UINT Size;
    DWORD FVF;
} D3DVERTEXBUFFER_DESC, *LPD3DVERTEXBUFFER_DESC;

typedef struct D3DINDEXBUFFER_DESC {
    D3DFORMAT Format;
    D3DRESOURCETYPE Type;
    DWORD Usage;
    D3DPOOL Pool;
    UINT Size;
} D3DINDEXBUFFER_DESC, *LPD3DINDEXBUFFER_DESC;

IDirect3DIndexBuffer9::GetDesc（）；

3.2 绘制状态

HRESULT SetRenderState(
  [in]  D3DRENDERSTATETYPE State,
  [in]  DWORD Value
);

3.3绘制准备工作

（1）制定数据流输入源

HRESULT SetStreamSource(
  UINT StreamNumber,      //数据流 可以是多个
  IDirect3DVertexBuffer9 * pStreamData,//建立数据流的缓存
  UINT OffsetInBytes,  //被传送到绘制流水线顶点数据的起始位置
  UINT Stride   //顶点缓存的大小
);

（2）设置顶点格式

HRESULT SetFVF(  DWORD FVF); 顶点格式如下：

（3）设置使用的索引，任意时刻只能有一个索引缓存，如果不同索引绘制物体时，必须进行切换

HRESULT SetIndices(
  IDirect3DIndexBuffer9 * pIndexData
);

3.4 绘制方法

使用顶点绘制

HRESULT DrawPrimitive(  

D3DPRIMITIVETYPE PrimitiveType,  //绘制的图元类型，TRIANGLELIST 

UINT StartVertex,  //绘制起点索引
UINT PrimitiveCount  //绘制的图元数量

);

采用索引绘制

HRESULT DrawIndexedPrimitive(
  D3DPRIMITIVETYPE Type,
  INT BaseVertexIndex,  //物体顶点在全局缓存中的起始位置偏移
  UINT MinIndex,
  UINT NumVertices,
  UINT StartIndex,
  UINT PrimitiveCount
);

绘制在下列函数之间进行

IDirect3DDevice9::BeginScene（）

IDirect3DDevice9::EndScene（）

 

实例：看完代码之后 多的一层了解：

（1）世界变换矩阵，取景变换矩阵，投影变换矩阵设置后 在绘图中起作用

（2）缓存中其实就在准备数据

 

#include "d3dUtility.h"

IDirect3DDevice9* Device = 0;

const int Width  = 640;
const int Height = 480;

IDirect3DVertexBuffer9* VB = 0;
IDirect3DIndexBuffer9*  IB = 0;

//顶点格式定义
struct Vertex
{
    Vertex(){}
    Vertex(float x, float y, float z)
    {
        _x = x;  _y = y;  _z = z;
    }
    float _x, _y, _z;
    static const DWORD FVF;
};
//全局定点格式
const DWORD Vertex::FVF = D3DFVF_XYZ;

//
// Framework Functions
//
bool Setup()
{
    // Create vertex and index buffers.
    Device->CreateVertexBuffer(
        8 * sizeof(Vertex),
        D3DUSAGE_WRITEONLY,
        Vertex::FVF,
        D3DPOOL_MANAGED,
        &VB,
        0);
    Device->CreateIndexBuffer(
        36 * sizeof(WORD),
        D3DUSAGE_WRITEONLY,
        D3DFMT_INDEX16,
        D3DPOOL_MANAGED,
        &IB,
        0);


    // 填充数据
    Vertex* vertices;
    VB->Lock(0, 0, (void**)&vertices, 0);

    // vertices of a unit cube
    vertices[0] = Vertex(-1.0f, -1.0f, -1.0f);
    vertices[1] = Vertex(-1.0f,  1.0f, -1.0f);
    vertices[2] = Vertex( 1.0f,  1.0f, -1.0f);
    vertices[3] = Vertex( 1.0f, -1.0f, -1.0f);
    vertices[4] = Vertex(-1.0f, -1.0f,  1.0f);
    vertices[5] = Vertex(-1.0f,  1.0f,  1.0f);
    vertices[6] = Vertex( 1.0f,  1.0f,  1.0f);
    vertices[7] = Vertex( 1.0f, -1.0f,  1.0f);

    VB->Unlock();

    // define the triangles of the cube:
    WORD* indices = 0;
    IB->Lock(0, 0, (void**)&indices, 0);

    // front side
    indices[0]  = 0; indices[1]  = 1; indices[2]  = 2;
    indices[3]  = 0; indices[4]  = 2; indices[5]  = 3;

    // back side
    indices[6]  = 4; indices[7]  = 6; indices[8]  = 5;
    indices[9]  = 4; indices[10] = 7; indices[11] = 6;

    // left side
    indices[12] = 4; indices[13] = 5; indices[14] = 1;
    indices[15] = 4; indices[16] = 1; indices[17] = 0;

    // right side
    indices[18] = 3; indices[19] = 2; indices[20] = 6;
    indices[21] = 3; indices[22] = 6; indices[23] = 7;

    // top
    indices[24] = 1; indices[25] = 5; indices[26] = 6;
    indices[27] = 1; indices[28] = 6; indices[29] = 2;

    // bottom
    indices[30] = 4; indices[31] = 0; indices[32] = 3;
    indices[33] = 4; indices[34] = 3; indices[35] = 7;

    IB->Unlock();

    D3DXVECTOR3 position(0.0f, 0.0f, -5.0f);
    D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
    D3DXMATRIX V;

    D3DXMatrixLookAtLH(&V, &position, &target, &up);
    //设置取景变换矩阵
    Device->SetTransform(D3DTS_VIEW, &V);

    // Set the projection matrix.
    D3DXMATRIX proj;
    D3DXMatrixPerspectiveFovLH(
            &proj,
            D3DX_PI * 0.5f, // 90 - degree
            (float)Width / (float)Height,
            1.0f,
            1000.0f);

    //设置投影变换矩阵
    Device->SetTransform(D3DTS_PROJECTION, &proj);

    //设置绘图模式
    Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

    return true;
}

void Cleanup()
{
    d3d::Release<IDirect3DVertexBuffer9*>(VB);
    d3d::Release<IDirect3DIndexBuffer9*>(IB);
}

bool Display(float timeDelta)
{
    if( Device )
    {
        // spin the cube:
        D3DXMATRIX Rx, Ry;

        // rotate 45 degrees on x-axis
        D3DXMatrixRotationX(&Rx, 3.14f / 4.0f);

        // incremement y-rotation angle each frame
        static float y = 0.0f;
        D3DXMatrixRotationY(&Ry, y);
        y += timeDelta;     // 每帧增加旋转量

        // reset angle to zero when angle reaches 2*PI
        if( y >= 6.28f )
            y = 0.0f;

        // combine x- and y-axis rotation transformations.
        D3DXMATRIX p = Rx * Ry;

        //设置世界变换矩阵
        Device->SetTransform(D3DTS_WORLD, &p);

        //
        // draw the scene:

        //清除背景
        Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
        Device->BeginScene();

        //设置数据源
        Device->SetStreamSource(0, VB, 0, sizeof(Vertex));

        //设置使用的索引
        Device->SetIndices(IB);

        //
        Device->SetFVF(Vertex::FVF);

        // Draw cube.
        Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);

        Device->EndScene();
        Device->Present(0, 0, 0, 0);
    }
    return true;
}


//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {
    case WM_DESTROY:
        ::PostQuitMessage(0);
        break;

    case WM_KEYDOWN:
        if( wParam == VK_ESCAPE )
            ::DestroyWindow(hwnd);
        break;
    }
    return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
                   HINSTANCE prevInstance,
                   PSTR cmdLine,
                   int showCmd)
{
    if(!d3d::InitD3D(hinstance,
        Width, Height, true, D3DDEVTYPE_HAL, &Device))
    {
        ::MessageBox(0, "InitD3D() - FAILED", 0, 0);
        return 0;
    }

    if(!Setup())
    {
        ::MessageBox(0, "Setup() - FAILED", 0, 0);
        return 0;
    }

    d3d::EnterMsgLoop( Display );

    Cleanup();

    Device->Release();

    return 0;
}