DirectX学习笔记--索引缓存绘图

àì夳堔傛蜴生んèń 2022-07-31 19:58 400阅读 0赞

引言：

顶点缓存绘制图形，虽然比较简单，但是简单的图形还好。一个三角形，三个点。但是，比如我们要绘制一个立方体，需要6*2=12个三角形，总共要36个顶点，而实际上表示一个立方体只需要8个顶点就可以了。显然再使用顶点缓存绘图有些划不来，所以就有了索引缓存绘图。

定义：

索引缓存保存的就是一些索引，用于记录顶点缓存中每一个顶点的索引位置。这样，我们在定义顶点的时候，就不需要重复定义那些没有用的顶点坐标了，而是给出有用的顶点坐标，然后根据这些坐标在顶点缓存中的索引值给出顶点值，这样，大大方便了我们绘制图形。

步骤：

注意，索引缓存不是单独存在的，而是和顶点缓存配合使用的。使用索引缓存有以下几个步骤：

（这里只写了索引部分的，但是一定要注意索引是建立在顶点基础上的！顶点和索引都有的例子的在下面整个Demo中）

1.设计顶点格式，这个与顶点缓存一样，例如：

  1. //------------绘制图形步骤1.定义灵活顶点格式
  2. #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)//坐标为经过变换的屏幕坐标，顶点的颜色
  4. //------------根据上面定义的顶点格式，创建一个顶点的结构体
  5. struct stVertex
  6. {
  7.     float x, y, z,rhw;        //位置坐标
  8.     DWORD dwColor;            //颜色
  9. };

2.创建顶点缓存&索引缓存，创建的方式也与顶点缓存一样。只是方法变成了g_pDevice->CreateIndexBuffer（）。

这里只给出创建索引缓存的代码：

  1. LPDIRECT3DINDEXBUFFER9 g_pIB = NULL;
  6. //创建索引缓冲区
  7.     g_pDevice->CreateIndexBuffer(
  8.         48 * sizeof(WORD),      //缓冲区大小
  9.         0,                        //缓冲区属性
  10.         D3DFMT_INDEX16,            //索引大小，一般采用16位
  11.         D3DPOOL_DEFAULT,        //存储位置，默认为显卡缓存
  12.         &g_pIB,                    //索引缓冲区指针的指针
  13.         NULL                    //保留参数，NULL即可
  14.         );

3.填充顶点缓存以及索引缓存。填写的方法还是差不多。填之前要Lock，填完后要UnLock。中间把索引内容拷贝到缓冲区中。

这里只给出填充索引缓存的代码：

  1. //设置索引数组
  2.     WORD index[] = {0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 
  3.         8, 0, 8, 9, 0, 9, 10, 0, 10, 11, 0, 11, 12, 0, 12, 13, 0, 13, 14, 0, 14, 15, 0, 15, 16, 0, 16, 1};
  5.     WORD *pIneices = NULL;
  6.     //锁缓冲区
  7.     g_pIB->Lock(0, 0, (void**)&pIneices, 0);
  8.     //拷贝数据
  9.     memcpy(pIneices, index, sizeof(index));
  10.     //解锁
  11.     g_pIB->Unlock();

4.绘制图形。绘制部分有几个步骤也是和顶点缓存绘图一样。不同的在于setIndices设置索引缓存与绘制图形的函数

  1. g_pDevice->BeginScene();
  3.     //----------绘制图形步骤6.设置数据源，设置灵活顶点格式，绘制图元
  5.         //设置数据流来源
  6.     g_pDevice->SetStreamSource(
  7.         0,                        //数据流管道号（0-15）
  8.         g_pVB,                    //数据来源
  9.         0,                        //数据流偏移量
  10.         sizeof(stVertex)        //每个数据的字节数大小
  11.         );
  13.         //通知系统数据格式，以便解析数据
  14.     g_pDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
  16.     //设置索引缓存
  17.     g_pDevice->SetIndices(g_pIB);
  19.     //使用索引缓存绘制图形
  20.     g_pDevice->DrawIndexedPrimitive(
  21.         D3DPT_TRIANGLELIST, //三角形列
  22.         0,                    //顶点起点，从那个顶点开始做为索引
  23.         0,                    //最小索引值，通常为0
  24.         17,                    //索引顶点的个数
  25.         0,                    //起点索引，从第几个索引处开始绘制图元
  26.         16                    //图元个数
  27.         );
  29.     g_pDevice->EndScene();

写了一个完整的Demo，绘制一个16边形：

思路：给出一个中心点，以及外围的16个点，根据三角函数以及半径求得每个点的坐标。如果用顶点缓冲区绘图需要 3 * 16个顶点。而这里我们使用索引缓冲区绘图，只需要定义每个顶点即可。即16 + 1 = 17个顶点。

上Demo:

  1. // D3DDemo.cpp : 定义应用程序的入口点。
  2. //
  4. #include "stdafx.h"
  5. #include "D3DDemo.h"
  7. #define MAX_LOADSTRING 100
  9. // 全局变量:
  10. HINSTANCE hInst;                                // 当前实例
  11. TCHAR szTitle[MAX_LOADSTRING];                    // 标题栏文本
  12. TCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名
  14. // 此代码模块中包含的函数的前向声明:
  15. HWND                g_hWnd;
  16. ATOM                MyRegisterClass(HINSTANCE hInstance);
  17. BOOL                InitInstance(HINSTANCE, int);
  18. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
  20. //---------改造3D窗口需要的内容------------
  21. LPDIRECT3D9 g_pD3D = NULL; //D3D接口指针
  22. LPDIRECT3DDEVICE9 g_pDevice = NULL;//D3D设备指针
  25. //------------绘制图形步骤1.定义灵活顶点格式
  26. #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)//坐标为经过变换的屏幕坐标，顶点的颜色
  28. //------------绘制图形步骤2.根据上面定义的顶点格式，创建一个顶点的结构体
  29. struct stVertex
  30. {
  31.     float x, y, z,rhw;        //位置坐标
  32.     DWORD dwColor;            //颜色
  33. };
  35. //----------绘制图形步骤3.声明一个顶点缓冲区指针&一个索引缓冲区指针
  36. LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;
  37. LPDIRECT3DINDEXBUFFER9 g_pIB = NULL;
  39. //初始化顶点缓冲区
  40. void initVB()
  41. {
  42.     //----------绘制图形步骤4.定义一个结构体数组用来给每个顶点赋值
  43.     //数组中存储当前程序中顶点的数据
  46.     stVertex vertex[17];
  47.     vertex[0].x = 400.0f;
  48.     vertex[0].y = 300.0f;
  49.     vertex[0].z = 0.0f;
  50.     vertex[0].rhw = 1.0f;
  51.     vertex[0].dwColor = D3DCOLOR_XRGB(rand()%256, rand()%256, rand()%256);
  52.     for (int i = 0; i <16; i++)
  53.     {
  54.         vertex[i + 1].x = (float)(250 * sin(i * 3.14 / 8.0)) + 400;
  55.         vertex[i + 1].y = (float)(250 * cos(i * 3.14 / 8.0)) + 300;
  56.         vertex[i + 1].z = 0.0f;
  57.         vertex[i + 1].rhw = 1.0f;
  58.         vertex[i + 1].dwColor = D3DCOLOR_XRGB(rand()%256, rand()%256, rand()%256);
  59.     };
  61.     //----------绘制图形步骤5.为定点缓冲区分配内存，并将数组中的顶点值拷贝到顶点缓冲区中
  62.     //通过设备指针来创建顶点缓冲区，用来存储顶点数据
  63.     g_pDevice->CreateVertexBuffer(
  64.         sizeof(vertex),                    //顶点缓冲区大小
  65.         D3DUSAGE_WRITEONLY,                //顶点缓冲区作用
  66.         D3DFVF_CUSTOMVERTEX,            //通知系统顶点格式
  67.         D3DPOOL_MANAGED,                //顶点缓冲区存储位置，此处表示由系统处理
  68.         &g_pVB,                            //返回顶点缓冲区指针
  69.         NULL                            //系统保留参数，NULL
  70.         );
  72.     void* pVertices = NULL;
  74.     //锁定顶点缓冲区，向其中拷贝数据
  75.     g_pVB->Lock(
  76.         0,                                //锁定的偏移量
  77.         sizeof(vertex),                    //锁定的大小
  78.         &pVertices,                        //锁定之后存储空间
  79.         0                                //锁定的标识，0
  80.         );
  82.     //将数组中的内容拷贝到缓冲区中
  83.     memcpy(pVertices, vertex, sizeof(vertex));
  85.     //解锁
  86.     g_pVB->Unlock();
  88. }
  90. //初始化索引缓冲区
  91. void initIB()
  92. {
  93.     //创建索引缓冲区
  94.     g_pDevice->CreateIndexBuffer(
  95.         48 * sizeof(WORD),      //缓冲区大小
  96.         0,                        //缓冲区属性
  97.         D3DFMT_INDEX16,            //索引大小，一般采用16位
  98.         D3DPOOL_DEFAULT,        //存储位置，默认为显卡缓存
  99.         &g_pIB,                    //索引缓冲区指针的指针
  100.         NULL                    //保留参数，NULL即可
  101.         );
  102.     //设置索引数组
  103.     WORD index[] = {0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 
  104.         8, 0, 8, 9, 0, 9, 10, 0, 10, 11, 0, 11, 12, 0, 12, 13, 0, 13, 14, 0, 14, 15, 0, 15, 16, 0, 16, 1};
  106.     WORD *pIneices = NULL;
  107.     //锁缓冲区
  108.     g_pIB->Lock(0, 0, (void**)&pIneices, 0);
  109.     //拷贝数据
  110.     memcpy(pIneices, index, sizeof(index));
  111.     //解锁
  112.     g_pIB->Unlock();
  113. }
  116. void onCreatD3D()
  117. {
  118.     g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
  119.     if (!g_pD3D)
  120.         return;
  122.     //检测硬件设备能力的方法
  123.     /*D3DCAPS9 caps;
  124.     ZeroMemory(&caps, sizeof(caps));
  125.     g_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);*/
  127.     //获得相关信息，屏幕大小，像素点属性
  128.     D3DDISPLAYMODE d3ddm;
  129.     ZeroMemory(&d3ddm, sizeof(d3ddm));
  131.     g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm);
  134.     //设置全屏模式
  135.     D3DPRESENT_PARAMETERS d3dpp;
  136.     ZeroMemory(&d3dpp, sizeof(d3dpp));
  137.     /*d3dpp.Windowed = false;
  138.     d3dpp.BackBufferWidth = d3ddm.Width;
  139.     d3dpp.BackBufferHeight = d3ddm.Height;*/
  141.     d3dpp.Windowed = true;
  142.     d3dpp.BackBufferFormat = d3ddm.Format;
  143.     d3dpp.BackBufferCount = 1;
  145.     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;//交换后原缓冲区数据丢弃
  147.     //是否开启自动深度模板缓冲
  148.     d3dpp.EnableAutoDepthStencil = true;
  149.     //当前自动深度模板缓冲的格式
  150.     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;//每个像素点有16位的存储空间，存储离摄像机的距离
  153.     g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pDevice);
  155.     if (!g_pDevice)
  156.         return;
  158.     //设置渲染状态，设置启用深度值
  159.     g_pDevice->SetRenderState(D3DRS_ZENABLE, true);
  161.     //设置渲染状态，关闭灯光
  162.     g_pDevice->SetRenderState(D3DRS_LIGHTING, false);
  164.     //设置渲染状态，裁剪模式
  165.     g_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
  167.     //g_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE) ;
  169. }
  171. void onInit()
  172. {
  173.     //初始化D3D
  174.     onCreatD3D();
  176.     //初始化顶点缓冲区
  177.     initVB();
  178.     //初始化索引缓冲区
  179.     initIB();
  180. }
  182. void onDestroy()
  183. {
  184.     if (!g_pDevice)
  185.         g_pDevice->Release();
  186.     g_pDevice = NULL;
  187. }
  189. void onLogic(float fElapsedTime)
  190. {
  192. }
  194. void onRender(float fElasedTime)
  195. {
  196.     //前两个参数是0和NULL时，清空整个游戏窗口的内容（清的是后台）
  197.     //第三个是清除的对象：前面表示清除颜色缓冲区，后面表示清除深度缓冲区,D3DCLEAR_STENCIL清空模板缓冲区
  198.     g_pDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,100,100), 1.0f, 0);
  200.     g_pDevice->BeginScene();
  202.     //----------绘制图形步骤6.设置数据源，设置灵活顶点格式，绘制图元
  204.         //设置数据流来源
  205.     g_pDevice->SetStreamSource(
  206.         0,                        //数据流管道号（0-15）
  207.         g_pVB,                    //数据来源
  208.         0,                        //数据流偏移量
  209.         sizeof(stVertex)        //每个数据的字节数大小
  210.         );
  212.         //通知系统数据格式，以便解析数据
  213.     g_pDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
  215.     绘制图元 
  216.     //g_pDevice->DrawPrimitive(
  217.     //    D3DPT_TRIANGLESTRIP,     //三角形列
  218.     //    0,                        //起始点编号
  219.     //    15                        //图元数量
  220.     //    );
  222.     //设置索引缓存
  223.     g_pDevice->SetIndices(g_pIB);
  225.     //使用索引缓存绘制图形
  226.     g_pDevice->DrawIndexedPrimitive(
  227.         D3DPT_TRIANGLELIST, //三角形列
  228.         0,                    //顶点起点，从那个顶点开始做为索引
  229.         0,                    //最小索引值，通常为0
  230.         17,                    //索引顶点的个数
  231.         0,                    //起点索引，从第几个索引处开始绘制图元
  232.         16                    //图元个数
  233.         );
  235.     g_pDevice->EndScene();
  238.     g_pDevice->Present(NULL, NULL, NULL, NULL);
  239. }
  242. int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
  243.                      _In_opt_ HINSTANCE hPrevInstance,
  244.                      _In_ LPTSTR    lpCmdLine,
  245.                      _In_ int       nCmdShow)
  246. {
  247.     UNREFERENCED_PARAMETER(hPrevInstance);
  248.     UNREFERENCED_PARAMETER(lpCmdLine);
  250.      // TODO: 在此放置代码。
  251.     MSG msg;
  252.     HACCEL hAccelTable;
  254.     // 初始化全局字符串
  255.     LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  256.     LoadString(hInstance, IDC_D3DDEMO, szWindowClass, MAX_LOADSTRING);
  257.     MyRegisterClass(hInstance);
  259.     // 执行应用程序初始化:
  260.     if (!InitInstance (hInstance, nCmdShow))
  261.     {
  262.         return FALSE;
  263.     }
  265.     hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_D3DDEMO));
  269.     ZeroMemory(&msg, sizeof(msg));
  270.     while (msg.message != WM_QUIT)
  271.     {
  272.         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  273.         {
  274.             TranslateMessage(&msg);
  275.             DispatchMessage(&msg);
  276.         }
  277.         else
  278.         {
  279.             static DWORD dwTime = timeGetTime();
  280.             DWORD dwCurrentTime = timeGetTime();
  281.             DWORD dwElapsedTime = dwCurrentTime - dwTime;
  282.             float fElapsedTime = dwElapsedTime * 0.001f;
  284.             //------------渲染和逻辑部分代码----------
  285.             onLogic(fElapsedTime);
  286.             onRender(fElapsedTime);
  287.             //-----------------------------------------
  288.             if (dwElapsedTime < 1000 / 60)
  289.             {
  290.                 Sleep(1000/ 60 - dwElapsedTime);
  291.             }
  292.             dwTime = dwCurrentTime;
  293.         }
  294.     }
  296.     onDestroy();
  297.     return (int) msg.wParam;
  298. }
  302. //
  303. //  函数: MyRegisterClass()
  304. //
  305. //  目的: 注册窗口类。
  306. //
  307. ATOM MyRegisterClass(HINSTANCE hInstance)
  308. {
  309.     WNDCLASSEX wcex;
  311.     wcex.cbSize = sizeof(WNDCLASSEX);
  313.     wcex.style            = CS_HREDRAW | CS_VREDRAW;
  314.     wcex.lpfnWndProc    = WndProc;
  315.     wcex.cbClsExtra        = 0;
  316.     wcex.cbWndExtra        = 0;
  317.     wcex.hInstance        = hInstance;
  318.     wcex.hIcon            = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_D3DDEMO));
  319.     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
  320.     wcex.hbrBackground    = (HBRUSH)(COLOR_WINDOW+1);
  321.     wcex.lpszMenuName    = MAKEINTRESOURCE(IDC_D3DDEMO);
  322.     wcex.lpszClassName    = szWindowClass;
  323.     wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
  325.     return RegisterClassEx(&wcex);
  326. }
  328. //
  329. //   函数: InitInstance(HINSTANCE, int)
  330. //
  331. //   目的: 保存实例句柄并创建主窗口
  332. //
  333. //   注释:
  334. //
  335. //        在此函数中，我们在全局变量中保存实例句柄并
  336. //        创建和显示主程序窗口。
  337. //
  338. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  339. {
  341.    hInst = hInstance; // 将实例句柄存储在全局变量中
  343.    g_hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  344.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  346.    if (!g_hWnd)
  347.    {
  348.       return FALSE;
  349.    }
  353.    SetMenu(g_hWnd, NULL);
  354.    ShowWindow(g_hWnd, nCmdShow);
  355.    UpdateWindow(g_hWnd);
  357.    onInit();
  359.    return TRUE;
  360. }
  362. //
  363. //  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
  364. //
  365. //  目的: 处理主窗口的消息。
  366. //
  367. //  WM_COMMAND    - 处理应用程序菜单
  368. //  WM_PAINT    - 绘制主窗口
  369. //  WM_DESTROY    - 发送退出消息并返回
  370. //
  371. //
  372. LRESULT CALLBACK WndProc(HWND g_hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  373. {
  374.     switch (message)
  375.     {
  376.     case WM_KEYDOWN:
  377.         if (wParam == VK_ESCAPE)
  378.             PostQuitMessage(0);
  379.         break;
  380.     case WM_CLOSE:
  381.         DestroyWindow(g_hWnd);
  382.         break;
  383.     case WM_DESTROY:
  384.         PostQuitMessage(0);
  385.         break;
  386.     default:
  387.         return DefWindowProc(g_hWnd, message, wParam, lParam);
  388.     }
  389.     return 0;
  390. }

run一下，还是很漂亮的！
Center

关于三角形的绕序以及三角形正反面的判定：

DirectX用的是左手坐标系，我们用左手除了大拇指的四个手指按顺时针方向对某个三角形绕圈，大拇指指的方向就是三角形正面了。

发表评论

表情：
评论列表 （有 0 条评论，400人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Directx 顶点和顶点缓存

    顶点     在dx11中，顶点由空间位置和各种附加属性组成。D3D允许我们灵活地建立属于自己的顶点格式。要创建一个自定义的顶点格式，必须创建一个包含顶点数据的结构体。  

    向右看齐向右看齐/ 0 赞/ 231 阅读