3d 十二面体三角形的顶点法线

我想初始化顶点法线以使用照明，但我不知道如何实现这一点

是我使用DirectX 9和C++编写的程序。它模拟了一个简单的行星轨道，没有实现照明，也没有顶点法线

我需要的是顶点数组和初始化索引数组中的顶点法线

  // include the basic windows header files and the Direct3D header file 
  #include <windows.h>
  #include <windowsx.h>
  #include <d3d9.h>
  #include <d3dx9.h> 
  #include <math.h>


  // define the screen resolution
  #define SCREEN_WIDTH 800
  #define SCREEN_HEIGHT 600

  // include the Direct3D Library files
 #pragma comment (lib, "d3d9.lib")
  #pragma comment (lib, "d3dx9.lib")

  // global declarations
  LPDIRECT3D9 d3d;
  LPDIRECT3DDEVICE9 d3ddev;
 LPDIRECT3DVERTEXBUFFER9 v_buffer = NULL;    // the pointer to the vertex buffer
   LPDIRECT3DINDEXBUFFER9 i_buffer = NULL;    // the pointer to the index buffer

  // function prototypes
  void initD3D(HWND hWnd);
  void render_frame(void);
  void cleanD3D(void);
  void init_graphics(void);

   struct CUSTOMVERTEX {FLOAT X, Y, Z; DWORD COLOR;};
   #define CUSTOMFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE )

   // the WindowProc function prototype
   LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);


  // the entry point for any Windows program
   int WINAPI WinMain(HINSTANCE hInstance,
               HINSTANCE hPrevInstance,
               LPSTR lpCmdLine,
               int nCmdShow)
  {
  HWND hWnd;
  WNDCLASSEX wc;

   ZeroMemory(&wc, sizeof(WNDCLASSEX));

  wc.cbSize = sizeof(WNDCLASSEX);
  wc.style = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc = WindowProc;
  wc.hInstance = hInstance;
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.lpszClassName = L"WindowClass";

  RegisterClassEx(&wc);

  hWnd = CreateWindowEx(NULL, L"WindowClass", L"Our Direct3D Program",
                      WS_OVERLAPPEDWINDOW, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
                      NULL, NULL, hInstance, NULL);

   ShowWindow(hWnd, nCmdShow);

  initD3D(hWnd);

  MSG msg;

   while(TRUE)
   {
    while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    if(msg.message == WM_QUIT)
        break;

    render_frame();
  }

   cleanD3D();

  return msg.wParam;
 }


   // this is the main message handler for the program
  LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
  switch(message)
  {
    case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        } break;
  }

   return DefWindowProc (hWnd, message, wParam, lParam);
   }


    // this function initializes and prepares Direct3D for use
    void initD3D(HWND hWnd)
    {
   d3d = Direct3DCreate9(D3D_SDK_VERSION);

     D3DPRESENT_PARAMETERS d3dpp;

     ZeroMemory(&d3dpp, sizeof(d3dpp));
     d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = hWnd;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferWidth = SCREEN_WIDTH;
    d3dpp.BackBufferHeight = SCREEN_HEIGHT;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

   d3d->CreateDevice(D3DADAPTER_DEFAULT,
                  D3DDEVTYPE_HAL,
                  hWnd,
                  D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                  &d3dpp,
                  &d3ddev);

    init_graphics();

    d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);    // turn off the 3D lighting
     d3ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);    // turn off culling
    d3ddev->SetRenderState(D3DRS_ZENABLE, TRUE);    // turn on the z-buffer
   }


    // this is the function used to render a single frame
   void render_frame(void)
   {
   d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
  d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

   d3ddev->BeginScene();

    d3ddev->SetFVF(CUSTOMFVF);

   // set the view transform
   D3DXMATRIX matView;    // the view transform matrix
   D3DXMatrixLookAtLH(&matView,
   &D3DXVECTOR3 (1.0f, 9.0f, 50.0f),    // the camera position
   &D3DXVECTOR3 (1.0f, 1.0f, 1.0f),      // the look-at position
    &D3DXVECTOR3 (1.0f, 2.0f, 1.0f));    // the up direction
    d3ddev->SetTransform(D3DTS_VIEW, &matView);    // set the view transform to matView 

   // set the projection transform
   D3DXMATRIX matProjection;    // the projection transform matrix
   D3DXMatrixPerspectiveFovLH(&matProjection,
                           D3DXToRadian(60),    // the horizontal field of view
                           (FLOAT)SCREEN_WIDTH / (FLOAT)SCREEN_HEIGHT, // aspect ratio
                           1.0f,   // the near view-plane
                           100.0f);    // the far view-plane
   d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection); // set the projection

   // set the world transform
   static float index = 0.0f; index+=0.03f; // an ever-increasing float value
   D3DXMATRIX matRotateY;    // a matrix to store the rotation for each triangle
D3DXMATRIX matTranslateX_venus;
D3DXMATRIX matTranslateX_merkurius;
D3DXMATRIX matTranslateX_sun;
D3DXMATRIX matScale_merkurius;
D3DXMATRIX matScale_sun;
D3DXMATRIX matTranslateX_earth;
D3DXMATRIX matTranslateX_mars;

  D3DXMatrixRotationY(&matRotateY, index);    // the rotation matrix
   D3DXMatrixTranslation(&matTranslateX_venus,16.0f,0.0f,0.0f);
  D3DXMatrixTranslation(&matTranslateX_earth,24.0f,0.0f,0.0f);
  D3DXMatrixTranslation(&matTranslateX_mars,32.0f,0.0f,0.0f);
   D3DXMatrixTranslation(&matTranslateX_merkurius,8.0f,0.0f,0.0f);
   D3DXMatrixTranslation(&matTranslateX_sun,0.0f,0.0f,0.0f);
   D3DXMatrixScaling(&matScale_merkurius, 0.5f, 0.5f, 0.5f);
    D3DXMatrixScaling(&matScale_sun, 2.5f, 2.5f, 2.5f);
   // set the world transform


  // select the vertex buffer to display
  d3ddev->SetStreamSource(0, v_buffer, 0, sizeof(CUSTOMVERTEX));
  d3ddev->SetIndices(i_buffer);

   // draw the pyramid

  d3ddev->SetTransform(D3DTS_WORLD, &(matScale_sun*matTranslateX_sun *matRotateY)); 
    d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 12, 0, 20);


  d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateX_venus * matRotateY)); 
  d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 12, 0, 12, 0, 20);

  d3ddev->SetTransform(D3DTS_WORLD, &(matScale_merkurius*matTranslateX_merkurius
    *         matRotateY));
  d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 24, 0, 12, 0, 20);

   d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateX_earth * matRotateY));
  d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 36, 0, 12, 0, 20);

   d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateX_mars * matRotateY));
  d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 48, 0, 12, 0, 20);
   d3ddev->EndScene(); 

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


  // this is the function that cleans up Direct3D and COM
  void cleanD3D(void)
  {
    v_buffer->Release();
    i_buffer->Release();
    d3ddev->Release();
  d3d->Release();
  }


   // this is the function that puts the 3D models into video RAM
   void init_graphics(void)
  {
// create the vertices using the CUSTOMVERTEX
float t = (1.0 + sqrt(5.0)) / 2.0;
struct CUSTOMVERTEX vertices[] =
{
    {-1, t, 0, D3DCOLOR_XRGB(255,255,0), }, 
    {1, t, 0, D3DCOLOR_XRGB(255,255,0), },
    {-1, -t, 0, D3DCOLOR_XRGB(255,255,0), },
    {1, -t, 0, D3DCOLOR_XRGB(255,255,0), },
    {0, -1, t, D3DCOLOR_XRGB(255,255,0), },
    {0, 1, t, D3DCOLOR_XRGB(255,255,0), },
    {0, -1, -t, D3DCOLOR_XRGB(255,255,0), },
    {0, 1, -t, D3DCOLOR_XRGB(255,255,0), },
    {t, 0, -1, D3DCOLOR_XRGB(255,255,0), },
    {t, 0, 1, D3DCOLOR_XRGB(255,255,0), },
    {-t, 0, -1, D3DCOLOR_XRGB(255,255,0), },
    {-t, 0, 1, D3DCOLOR_XRGB(255,255,0), },

    {-1, t, 0, D3DCOLOR_XRGB(88,90,97), }, 
    {1, t, 0, D3DCOLOR_XRGB(88,90,97), },
    {-1, -t, 0, D3DCOLOR_XRGB(88,90,97), },
    {1, -t, 0, D3DCOLOR_XRGB(88,90,97), },
    {0, -1, t, D3DCOLOR_XRGB(88,90,97), },
    {0, 1, t, D3DCOLOR_XRGB(88,90,97), },
    {0, -1, -t, D3DCOLOR_XRGB(88,90,97), },
    {0, 1, -t, D3DCOLOR_XRGB(88,90,97), },
    {t, 0, -1, D3DCOLOR_XRGB(88,90,97), },
    {t, 0, 1, D3DCOLOR_XRGB(88,90,97), },
    {-t, 0, -1, D3DCOLOR_XRGB(88,90,97), },
    {-t, 0, 1, D3DCOLOR_XRGB(88,90,97), },

    {-1, t, 0, D3DCOLOR_XRGB(136,108,57), }, 
    {1, t, 0, D3DCOLOR_XRGB(136,108,57), },
    {-1, -t, 0, D3DCOLOR_XRGB(136,108,57), },
    {1, -t, 0, D3DCOLOR_XRGB(136,108,57), },
    {0, -1, t, D3DCOLOR_XRGB(136,108,57), },
    {0, 1, t, D3DCOLOR_XRGB(136,108,57), },
    {0, -1, -t, D3DCOLOR_XRGB(136,108,57), },
    {0, 1, -t, D3DCOLOR_XRGB(136,108,57), },
    {t, 0, -1, D3DCOLOR_XRGB(136,108,57), },
    {t, 0, 1, D3DCOLOR_XRGB(136,108,57), },
    {-t, 0, -1, D3DCOLOR_XRGB(136,108,57), },
    {-t, 0, 1, D3DCOLOR_XRGB(136,108,57), },

    {-1, t, 0, D3DCOLOR_XRGB(14,51,180), }, 
    {1, t, 0, D3DCOLOR_XRGB(14,51,180), },
    {-1, -t, 0, D3DCOLOR_XRGB(14,51,180), },
    {1, -t, 0, D3DCOLOR_XRGB(14,51,180), },
    {0, -1, t, D3DCOLOR_XRGB(14,51,180), },
    {0, 1, t, D3DCOLOR_XRGB(14,51,180), },
    {0, -1, -t, D3DCOLOR_XRGB(14,51,180), },
    {0, 1, -t, D3DCOLOR_XRGB(14,51,180), },
    {t, 0, -1, D3DCOLOR_XRGB(14,51,180), },
    {t, 0, 1, D3DCOLOR_XRGB(14,51,180), },
    {-t, 0, -1, D3DCOLOR_XRGB(14,51,180), },
    {-t, 0, 1, D3DCOLOR_XRGB(14,51,180), },

    {-1, t, 0, D3DCOLOR_XRGB(192,49,1), }, 
    {1, t, 0, D3DCOLOR_XRGB(192,49,1), },
    {-1, -t, 0, D3DCOLOR_XRGB(192,49,1), },
    {1, -t, 0, D3DCOLOR_XRGB(192,49,1), },
    {0, -1, t, D3DCOLOR_XRGB(192,49,1), },
    {0, 1, t, D3DCOLOR_XRGB(192,49,1), },
    {0, -1, -t, D3DCOLOR_XRGB(192,49,1), },
    {0, 1, -t, D3DCOLOR_XRGB(192,49,1), },
    {t, 0, -1, D3DCOLOR_XRGB(192,49,1), },
    {t, 0, 1, D3DCOLOR_XRGB(192,49,1), },
    {-t, 0, -1, D3DCOLOR_XRGB(192,49,1), },
    {-t, 0, 1, D3DCOLOR_XRGB(192,49,1), },


};

// create a vertex buffer interface called v_buffer
d3ddev->CreateVertexBuffer(60*sizeof(CUSTOMVERTEX),
                           0,
                           CUSTOMFVF,
                           D3DPOOL_MANAGED,
                           &v_buffer,
                           NULL);

   VOID* pVoid;    // a void pointer

  // lock v_buffer and load the vertices into it
  v_buffer->Lock(0, 0, (void**)&pVoid, 0);
   memcpy(pVoid, vertices, sizeof(vertices));
  v_buffer->Unlock();

   // create the indices using an int array
   short indices[] =
  {
  // 5 faces around p0
  0, 11, 5,
  0, 5, 1,
  0, 1, 7,
  0, 7, 10,
  0, 10, 11,
   // 5 adjacent faces
   1, 5, 9,
   5, 11, 4,
   11, 10, 2,
  10, 7, 6,
   7, 1, 8,
    // 5 faces around point p3
  3, 9, 4,
  3, 4, 2,
  3, 2, 6,
  3, 6, 8,
  3, 8, 9,
  // 5 adjacent faces
  4, 9, 5,
  2, 4, 11,
 6, 2, 10,
  8, 6, 7,
  9, 8, 1
  };

  // create a index buffer interface called i_buffer
 d3ddev->CreateIndexBuffer(60*sizeof(short),
                      0,
                      D3DFMT_INDEX16,
                      D3DPOOL_MANAGED,
                      &i_buffer,
                      NULL);

  // lock i_buffer and load the indices into it
  i_buffer->Lock(0, 0, (void**)&pVoid, 0);
 memcpy(pVoid, indices, sizeof(indices));
  i_buffer->Unlock(); 
 }

//包括基本windows头文件和Direct3D头文件
#包括
#包括
#包括
#包括
#包括
//定义屏幕分辨率
#定义屏幕宽度800
#定义屏幕高度600
//包括Direct3D库文件
#pragma注释（lib，“d3d9.lib”）
#pragma注释（lib，“d3dx9.lib”）
//全球宣言
LPDIRECT3D9-d3d；
LPDIRECT3DDEVICE9 d3ddev；
LPDIRECT3DVERTEXBUFFER9 v_buffer=NULL；//指向顶点缓冲区的指针
LPDIRECT3DINDEXBUFFER9 i_buffer=NULL；//指向索引缓冲区的指针
//功能原型
无效初始d3d（HWND-HWND）；
空心框架（空心）；
空隙清除3d（空隙）；
void init_图形（void）；
结构自定义顶点{FLOAT X，Y，Z；DWORD COLOR；}；
#定义自定义FVF（D3DFVF_XYZ | D3DFVF_DIFFUSE）
//WindowProc函数原型
LRESULT回调WindowProc（HWND-HWND，UINT消息，WPARAM-WPARAM，LPARAM-LPARAM）；
//任何Windows程序的入口点
int WINAPI WinMain（HINSTANCE HINSTANCE，
HINSTANCE HPPrevenstance，
LPSTR lpCmdLine，
国际展览（nCmdShow）
{
HWND-HWND；
WNDCLASSEX wc；
零内存（&wc，sizeof（WNDCLASSEX））；
wc.cbSize=sizeof（WNDCLASSEX）；
wc.style=CS_HREDRAW | CS_VREDRAW；
wc.lpfnWndProc=WindowProc；
wc.hInstance=hInstance；
wc.hCursor=LoadCursor（空，IDC_箭头）；
wc.lpszClassName=L“WindowClass”；
注册类别（&wc）；
hWnd=CreateWindowEx（空，L“WindowClass”，L“我们的Direct3D程序”，
WS_重叠窗口，0，0，屏幕宽度，屏幕高度，
NULL，NULL，hInstance，NULL）；
显示窗口（hWnd、nCmdShow）；
initD3D（hWnd）；
味精；
while（TRUE）
{
while（peek消息（&msg，NULL，0，0，PM_-REMOVE））
{
翻译信息（&msg）；
发送消息（&msg）；
}
如果（msg.message==WM\u退出）
打破
渲染_帧（）；
}
清洁d3d（）；
返回msg.wParam；
}
//这是程序的主要消息处理程序
LRESULT回调WindowProc（HWND-HWND，UINT消息，WPARAM-WPARAM，LPARAM-LPARAM）
{
开关（信息）
{
案例WM_销毁：
{
PostQuitMessage（0）；
返回0；
}中断；
}
返回DefWindowProc（hWnd、message、wParam、lParam）；
}
//此函数用于初始化和准备Direct3D以供使用
无效初始D3D（HWND HWND）
{
d3d=Direct3DCreate9（d3d_SDK_版本）；
D3D当前参数d3dpp；
零内存（&d3dpp，sizeof（d3dpp））；
d3dpp.Windowed=TRUE；
d3dpp.SwapEffect=d3dswapeeffect_DISCARD；
d3dpp.hDeviceWindow=hWnd；
d3dpp.BackBufferFormat=D3DFMT_X8R8G8B8；
d3dpp.BackBufferWidth=屏幕宽度；
d3dpp.BackBufferHeight=屏幕高度；
d3dpp.EnableAutoDepthStencil=TRUE；
d3dpp.AutoDepthStencilFormat=D3DFMT_D16；
d3d->CreateDevice（D3DADAPTER_默认值，
D3DDEVTYPE_HAL，
hWnd，
D3DCREATE_SOFTWARE_VERTEXPROCESSING，
&民进党,，
&d3ddev）；
初始化图形（）；
d3ddev->SetRenderState（D3DRS_照明，错误）；//关闭3D照明
d3ddev->SetRenderState（D3DRS_CULLMODE，D3DCULL_NONE）；//关闭消隐
d3ddev->SetRenderState（D3DRS_ZENABLE，TRUE）；//打开z缓冲区
}
//这是用于渲染单个帧的函数
void渲染帧（void）
{
d3ddev->清除（0，空，D3DCLEAR_目标，D3DCOLOR_XRGB（0，0，0），1.0f，0）；
d3ddev->清除（0，空，D3DCLEAR_ZBUFFER，D3DCOLOR_XRGB（0，0，0），1.0f，0）；
d3ddev->BeginScene（）；
d3ddev->SetFVF（自定义FVF）；
//设置视图变换
D3DXMATRIX matView；//视图变换矩阵
D3DXMatrixLookAtLH和matView，
&D3DXVECTOR3（1.0f、9.0f、50.0f），//摄像机位置
&D3DXVECTOR3（1.0f，1.0f，1.0f），//观察位置
&D3DXVECTOR3（1.0f，2.0f，1.0f））；//向上方向
d3ddev->SetTransform（D3DTS_视图和matView）；//将视图转换设置为matView
//设置投影变换
D3DXMATRIX matProjection；//投影变换矩阵
D3DXMatrixPerspectiveFovLH和matProjection，
D3DXToRadian（60），//水平视野
（浮动）屏幕宽度/（浮动）屏幕高度，//纵横比
1.0f，//近视图平面
100.0f）；//远视图平面
d3ddev->SetTransform（D3DTS_投影和matProjection）；//设置投影
//改变世界
静态浮点索引=0.0f；索引+=0.03f；//一个不断增加的浮点值
D3DXMATRIX matRotateY；//存储每个三角形旋转的矩阵
D3DX矩阵Mattrans_venus；
D3DX矩阵Mattrans_merkurius；
D3DXMATRIX Mattransu sun；
D3DX矩阵matScale_merkurius；
D3DX矩阵matScale_sun；
d3dx矩阵mattranu-earth；
d3dx矩阵mattransu-mars；
D3DXMatrixRotationY（&matRotateY，index）；//旋转矩阵
D3DX矩阵翻译（&Mattranslation_venus，16.0f，0.0f，0.0f）；
D3DX矩阵翻译（和MatTranslation_earth，24.0f，0.0f，0.0f）；
D3DXMatrixtransation（&matTranslateX_mars，32.0f，0.0f，0.0f）；
d3dx矩阵翻译（和matTranslateX_merkurius，8.0f，0.0f，0.0f）；
d3dx矩阵翻译（和mattranslation_sun，0.0f，0.0f，0.0f）；
D3DXMatrixScaling（和matScale_merkurius，0.5f、0.5f、0.5f）；
D3DXMatrixScaling（和matScale_sun，2.5f、2.5f、2.5f）；
//改变世界
//选择要显示的顶点缓冲区
d3ddev->SetStreamSource（0，v_缓冲区，0，sizeof（CUSTOMVERTEX））；
d3ddev->SETINDEX（i_缓冲区）；
//画