OpenGL入门宝典

按照惯例我还是要先说一些废话，OpenGL被严格定义为“一种到图形硬件的软件接口”。从本质上说，它是一个完全可移植并且速度很快的3D图形和建模库。使用OpenGL，你可以创建视觉质量接近射线跟踪程序的精致漂亮的3D图形。使用OpenGL的最大好处是它比射线跟踪程序要快好几个数量级。它使用由Silicon Graphcs(SGI)公司精心开发和优化的算法，这家公司在计算机图形和动画领域是公认的业界领袖。这并不是说每个人都应该用OpenGL为商业应用程序画饼图和柱形图。不过，外观非常重要，其它方面的功能大致相同的产品，其成功或失败常常取决于“吸引力”。而用漂亮的3D图形可以增加许多吸引力！这次我将带你进入真正的计算机三维时代，体验三维编程的魅力。我们将从OpenGL做为入手点，开始建立一个完全独立的应用程序，能够显示一些物体，并且在后面添加一些特效，使我们的显示画面更为美观。在阅读完本文之后，你应该可以写一些简单的三维小程序了，如果你是一个开发老手，那你也许可以拥有一个版权属于自己的3D小游戏吧？虽然这篇文章的起点很低，但在看下去之前还是需要你评估一下你的实际编程能力：熟练的使用VC.net开发环境和MSDN、写过完全独立的SDK程序、熟悉C语言和C++。请保持愉快的心情阅读全文。

　　首先让VC.net来为我们自动建立一个可以运行的SDK程序（这个你应该会吧？），名字叫做GlTest，然后来了解一下我们需要用到的头文件和导入库。一般在VC.net中，OpenGL的头文件是存放在系统头文件目录的子目录GL中的，所以在指定包含的时候要指定一下相对路径。gl.h是基本头文件，glu.h是应用头文件，大多数应用程序都需要同时包含这两个头文件。opengl32.lib则是OpenGL的win32实现的标准导入库，所以我们在刚刚建立的工程中的StdAfx.cpp的头文件声明区添加下面的编译器指令：

#pragma comment( lib, "opengl32.lib" )
#pragma comment( lib, "glu32.lib" )
#include <GL/gl.h>
#include <GL/glu.h>

　　在这之后，你就可以随意调用OpenGL的函数了。但是不得不稍带说明的是，VC.net附带的MSDN里有所有的OpenGL标准函数的定义说明，但仅是如此，与DirectX的教程比起来相去甚远。从这一点也可以看出微软在大的商业战略方针上是一力推崇DirectX，排斥其它的图形编程接口。如果你是一个初学者，并希望从MSDN的OpenGL的说明上得到你所想要的知识，那么我只能告诉你，你错了，应该去书店里买一本《OpenGL编程权威指南》，这本书里才有真正适合你的东西。现在你也许会对我的话不屑一顾，因为你不会花太多的精力和金钱在研究这类“无聊且无用的东西”上，仅仅是看这篇文章来消遗，那也无所谓，你现在要做的仅是保持耐心，继续看完全文。

　　我们还需要对VC.net自动生成的工程做一些修改，让它来适合我们的OpenGL应用。第一个要改的是消息循环，大多数时实渲染的应用程序都会把绘图的代码放在空闲事件里，空闲事件与其说是一种事件倒不如说它是“没有事件”，先看一下我们怎么写消息循环：

while ( true )
{
    if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        continue;
    }
    if ( WM_QUIT == msg.message )
    {
        break;
    }
    OnIdle();
}

　　使用PeekMessage而不是GetMessage，这样当消息队列中没有消息时便不会等待而是返回一个FALSE值，这样我们就可能知道当前应用程序处理空闲状态了。另外值得注意的是，如果得到的消息是WM_QUIT，PeekMessage一样会返回FALSE值，所以我们需要做一些特殊处理。在循环的最后回调我们的空闲消息处理函数：OnIdle(); 第二个要改的是注册窗体类时，wcex.style应该赋为0，因为这是一个实时渲染程序，并不需要系统来自动管理窗体的重绘，这样可以提高程序的速度。第三个要改动的地方是把消息处理回调函数中对WM_PAINT消息处理的代码屏蔽掉，使用default的return DefWindowProc(hWnd, message, wParam, lParam);就可以了，不然GDI的绘图会与OpenGL冲突，并且阻止程序空闲。

　　接下来就是最重要的部分了，初始化我们的OpenGL。先大致讲一下步骤：一，获取你需要在上面绘图的设备环境（DC）；二、为该设备环境设置像素格式；三、创建基于该设备环境的OpenGL设备；四、初始化OpenGL绘制场景及状态设置。下面我们来看前三步的代码：

g_hDC = GetDC( g_hWnd ); // 获取DC
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof(PIXELFORMATDESCRIPTOR) ); // 无关项置0
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR );
pfd.nVersion = 1;       // 版本号，必须为1
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; //前两项必须，PFD_DOUBLEBUFFER指定使用双缓冲
pfd.iPixelType = PFD_TYPE_RGBA; // 颜色格式为红、绿、蓝、透明
pfd.cColorBits = 24;    // 24位色深
pfd.cDepthBits = 32;    // 32位Z缓冲深度

SetPixelFormat( g_hDC, ChoosePixelFormat( g_hDC, &pfd ), &pfd ); // 选择一个像素格式，并设置到DC中

g_glRes = wglCreateContext( g_hDC ); // 创建OpenGL设备
wglMakeCurrent( g_hDC, g_glRes );    // 启用OpenGL设备

看了上面的代码及注释后，你应该很清楚每一条语句的作用了吧，很简单不是？不过别忘了，在WM_DESTROY消息触发时释放OpenGL资源：

ReleaseDC( g_hWnd, g_hDC );
wglDeleteContext( g_glRes );

这样OpenGL就以经初始化完毕了，这也就意味着你可以立即在OnIdle里使用OpenGL语句绘图了，虽然理论上是如此，但为了达到我们的效果——一个旋转的方盒——我们还需要再设置一下场景：

glEnable( GL_CULL_FACE ); // 将不渲染看不见的隐消面
glCullFace( GL_BACK );

glEnable( GL_DEPTH_TEST ); //无论绘制的先后，让距离远的物体总在距离近的物体后面。
glDepthFunc( GL_LEQUAL );

int LightPos[] = { 50, 50, 10, 1 }; // 最后一个指定这是一个无指向的点光源
float LightColor[] = { 0.3f, 0.3f, 0.3f, 1.0f }; // 1.0是最亮，0.3看起来并不那么刺眼
glEnable(GL_LIGHTING); // 打开光照状态，除非人为改变，该状态将一直保留到程序退出
glLightiv( GL_LIGHT0, GL_POSITION, LightPos ); // 设置灯光位置
glLightfv( GL_LIGHT0, GL_AMBIENT, LightColor ); // 环境色
glLightfv( GL_LIGHT0, GL_DIFFUSE, LightColor ); // 散射色
glEnable( GL_LIGHT0 ); // 打开第一个光源，你一共可以开8个
glEnable( GL_COLOR_MATERIAL ); //打开颜色材质
glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE ); // 我们可以为物体指定颜色
glShadeModel( GL_SMOOTH ); // 启用光滑的着色
glClearColor( 255.0f / 255.0f, 255.0f / 255.0f, 200.0f / 255.0f, 0.0 ); // 背景色
glColor3ub( 140, 200, 255 ); // 填充色

这里要稍带一提的是OpenGL是一种状态机模式，比如你用glEnable打开一个状态，在以后的绘图中将一直保留并应用这个状态，除非你调用glDisable及同类函数来改变该状态或程序退出。OpenGL绝大多数函数都是一种状态机，比如你设置了当前的纹理，那么纹理将不会自动改变。

　　下面要讲一些理论的东西了，请不要感到厌烦，因为如果没有这些知识，我们的三维教程将很难进行下去。为了方便的描述三维场景中物体的旋转、平移、缩放等空间变换操作，我们引入三维变换矩阵的概念。这是一个4X4的矩阵，当然单位矩阵的对角线上的值都是1了。看这貌似平凡的矩阵，里面却蕴藏着无数的神奇。比如在笛卡尔坐标系中有一个空间点，坐标是10, 10, 10，现在你想把这一点平移5, -2, 8个单位，那么你只需要将变换矩阵最后一行的前三列的值为别赋为5、-2和8再将空间点的坐标做为一个4X1的矩阵，最后一列补0再与变换矩阵求积（什么？你不会算矩阵相乘？！我倒！），得到的4X1矩阵的前三列值便是变换过的空间点坐标的X、Y和Z。同样的旋转、缩放也是大致的方法，区别仅在于变换矩阵里不同位置的值代表不同的含义。

现在我们将开始绘图。先确定一下视角：

// 设置模形矩阵
void SetModalMatrix( void )
{
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( ); // 单位化矩阵
// 这个函数是在OnIdle里被调用的，所以我们用下面的代码来实现物体的旋转
// 一个很容易理解的概念是，你绕着物体转和物体自己转在某些简单场景里的
// 的效果看起来是一样的，所以我们通过矩阵运算让眼睛点在一定高度做圆周
// 运动。知道圆的简化方程是：(sinα* r)^2 + (cosα* r)^2 = r^2，所以代码
// 很好理解。

    static float fRadius = 0;
    fRadius += 0.01f;
    if ( fRadius > M_PI * 2 )
    {
        fRadius = 0;
    }
    gluLookAt( cosf( fRadius ) * 30, sinf( fRadius ) * 30, 15.0,
        0.0, 0.0, 0.0, // 向原点坐标看去
        0.0, 0.0, 1.0 ); // 设置眼睛（摄影机）的方向向量，该向量表示眼表向上
}

// 设置透视矩阵
void SetProjMatrix( WORD wWidth, WORD wHeight )
{
    // 此函数将在WM_SIZE时被调用，所以应该设置一下glViewPort
    glViewport( 0, 0, wWidth, wHeight );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    // 这和照象机很类似，第一个参数设置镜头广角度，第二个参数是长宽比，后面是远近剪切。
    gluPerspective( 45.0, (double)wWidth / (double)wHeight, 1.0, 1000.0 );
}

然后我们在OnDraw里调用下面的代码：

// 先将上次渲染的残留物清为背景色
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glBegin( GL_QUADS ); // 设置绘制模式，我们画一个平面的四边形
glVertex2i( 5, 5 );
glVertex2i( 5, -5 );
glVertex2i( -5, -5 );
glVertex2i( -5, 5 );
SwapBuffers( g_hDC ); // 交换前后缓冲，双缓冲无闪烁

至此，GlTest.cpp中的代码因该是这个样子：

// GlTest.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "GlTest.h"
#define MAX_LOADSTRING 100


// 全局变量：
HINSTANCE hInst; // 当前实例
HWND g_hWnd;
HDC g_hDC;
HGLRC g_glRes;

TCHAR szTitle[MAX_LOADSTRING]; // 标题栏文本
TCHAR szWindowClass[MAX_LOADSTRING]; // 主窗口类名

// 此代码模块中包含的函数的前向声明：
void OnCreate( HWND hWnd );
void OnCreated( void );
void OnDestroy( void );
void OnDraw( void );
void SetProjMatrix( WORD wWidth, WORD wHeight );
void SetModalMatrix( void );
void OnIdle( void );

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
    // TODO: 在此放置代码。
    MSG msg;
    HACCEL hAccelTable;

    // 初始化全局字符串
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_GLTEST, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化：
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_GLTEST);

    // 主消息循环：
    while ( true )
    {
        if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
        {
            if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            continue;
        }
        if ( WM_QUIT == msg.message )
        {
            break;
        }
        OnIdle();
    }

    return (int) msg.wParam;
}



//
// 函数：MyRegisterClass()
//
// 目的：注册窗口类。
//
// 注释：
//
// 仅当希望在已添加到 Windows 95 的
// “RegisterClassEx”函数之前此代码与 Win32 系统兼容时，
// 才需要此函数及其用法。调用此函数
// 十分重要，这样应用程序就可以获得关联的
// “格式正确的”小图标。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style = 0;
    wcex.lpfnWndProc = (WNDPROC)WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_GLTEST);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName = (LPCTSTR)IDC_GLTEST;
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

    return RegisterClassEx(&wcex);
}

//
// 函数：InitInstance(HANDLE, int)
//
// 目的：保存实例句柄并创建主窗口
//
// 注释：
//
// 在此函数中，我们在全局变量中保存实例句柄并
// 创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // 将实例句柄存储在全局变量中

    CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

    if ( !g_hWnd )
    {
        return FALSE;
    }
    OnCreated();

    ShowWindow( g_hWnd, nCmdShow );
    UpdateWindow( g_hWnd);

    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    switch (message)
    {
    case WM_CREATE:
        OnCreate( hWnd );
        break;
    case WM_COMMAND:
        wmId = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // 分析菜单选择：
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_SIZE:
        SetProjMatrix( LOWORD( lParam ), HIWORD( lParam ) );
        break;
    case WM_DESTROY:
        OnDestroy();
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_INITDIALOG:
        return TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return TRUE;
        }
        break;
    }
    return FALSE;
}

void OnCreate( HWND hWnd )
{
    g_hWnd = hWnd;
}

void OnDestroy( void )
{
    ReleaseDC( g_hWnd, g_hDC );
    wglDeleteContext( g_glRes );
}

void OnCreated( void )
{
    g_hDC = GetDC( g_hWnd );
    PIXELFORMATDESCRIPTOR pfd;
    ZeroMemory( &pfd, sizeof(PIXELFORMATDESCRIPTOR) );
    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR );
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 32;

    SetPixelFormat( g_hDC, ChoosePixelFormat( g_hDC, &pfd ), &pfd );

    g_glRes = wglCreateContext( g_hDC );
    wglMakeCurrent( g_hDC, g_glRes );

    glEnable( GL_CULL_FACE );
    glCullFace( GL_BACK );

    glEnable( GL_DEPTH_TEST );
    glDepthFunc( GL_LEQUAL );

    int LightPos[] = { 50, 50, 10, 1 };
    float LightColor[] = { 0.3f, 0.3f, 0.3f, 1.0f };

    glEnable(GL_LIGHTING);
    glLightiv( GL_LIGHT0, GL_POSITION, LightPos );
    glLightfv( GL_LIGHT0, GL_AMBIENT, LightColor );
    glLightfv( GL_LIGHT0, GL_DIFFUSE, LightColor );
    glEnable( GL_LIGHT0 );
    glEnable( GL_COLOR_MATERIAL );
    glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );

    glShadeModel( GL_SMOOTH );

    glClearColor( 255.0f / 255.0f, 255.0f / 255.0f, 200.0f / 255.0f, 0.0 );
    glColor3ub( 140, 200, 255 );
}

void OnDraw( void )
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glBegin( GL_QUADS ); // 设置绘制模式，我们画一个平面的四边形
    glVertex2i( 5, 5 );
    glVertex2i( -5, 5 );
    glVertex2i( -5, -5 );
    glVertex2i( 5, -5 );
    glEnd();
    SwapBuffers( g_hDC ); // 交换前后缓冲，双缓冲无闪烁
}

void SetModalMatrix( void )
{
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    static float fRadius = 0;
    fRadius += 0.01f;
    if ( fRadius > M_PI * 2 )
    {
        fRadius = 0;
    }
    gluLookAt( cosf( fRadius ) * 30, sinf( fRadius ) * 30, 15.0,
        0.0, 0.0, 0.0,
        0.0, 0.0, 1.0 );
}

void SetProjMatrix( WORD wWidth, WORD wHeight )
{
    glViewport( 0, 0, wWidth, wHeight );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    gluPerspective( 45.0, (double)wWidth / (double)wHeight, 1.0, 1000.0 );
}

void OnIdle( void )
{
    SetModalMatrix();
    OnDraw();
}

现在程序可以运行了，告诉我你看到了什么？应该是一个旋转的平面四边形。你什么也没有看到？请仔细复查你上面写的程序，看是不是每一句都和我一样。如果你仍然得不到解决，可以发短消息给我来争取获得帮助的机会。但请注意，我并不会对每一个愚蠢的问题都做出答复，比如请不要问我为什么你的窗体创建不出来或VC.net在哪里下载。

当然，刚才说过我们是要绘制一个立方盒，我当然没有忘记，只是在这之前想让更多的读者熟悉一下OpenGL的绘图机制。其它方盒很简单，我们应该有这样一组数据，并把它做为全局变量。每个顶点用X、Y、Z三维short值来表示，一个八个顶点，你可以跟据这些数据在纸上手画一个正方体出来吗？

short nSrcBox[ 3 * 8 ] = {
5, 5, 0, 5, 5, 10,
5, -5, 0, 5, -5, 10,
-5, -5, 0, -5, -5, 10,
-5, 5, 0, -5, 5, 10,
};

在绘制时我们可以一个三角形一个三角形的画，也可以像上一个例子一样，一个四边形一个四边形的画，但为了后面我们要讲述的一些东东，先看三角形画吧。每一个面由两个三角形组成，一共六个面，十二个三角形。如果给上面的八个顶点编号为0-7，那么我们可以按照这样的顺序来画：

0, 4, 6, 0, 2, 4, 0, 6, 7, 0, 7, 1, 0, 3, 2, 0, 1, 3, 5, 2, 3, 5, 4, 2, 5, 6, 4, 5, 7, 6, 5, 1, 7, 5, 3, 1,

这里需要注意的是右手定则，在OpenGL中按照绘制一个三角形三维顶点的顺序，用右手正正握这个三角形，大姆指竖起的方向就是这个面的正方向。其实你已经在不知不觉中了解了什么是索引数组，就是上面那一堆数字，我们把他们保存起来，做为全局变量：

BYTE byIndex[36] ={
0, 4, 6, 0, 2, 4,
0, 6, 7, 0, 7, 1,
0, 3, 2, 0, 1, 3,
5, 2, 3, 5, 4, 2,
5, 6, 4, 5, 7, 6,
5, 1, 7, 5, 3, 1,
};

好了，现在是万事具体只欠东风了，怎么画呢？也许你会想到和上面的程序一样调用一个个的glVertex来绘制这些顶点，是的，你是正确的，但这样太慢而且太复杂了，算算你一共要写多少个glVertex呢？幸好OpenGL为我们提供了一个方便绘图机制：数组绘制。在初始化代码的最下面加上这样的语句来指定顶点数组：

glEnableClientState( GL_VERTEX_ARRAY ); // 启用顶点数组
glVertexPointer( 3, GL_SHORT, 0, nSrcBox ); // 设置顶点数组地址

然后在OnDraw的Clear和Swap之间加上这一句话就足够了：

// 后两个参数指定索引数组值的类型和数组地址
glDrawElements( GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, byIndex );

你应该可以看到一个旋转的立方体了，但它仍然是混沌一片，看不清棱角，这是由于你没有指定光线反射的方向，下面我们将再引入一个概念“法向量”。在现实生活中，人眼看到物体是由于物体对光线的反射，如果物体不反射光，或着不向人的眼睛方向反射，人眼将认为这个物体是没有光照的。先不说漫反射，每一个镜面反射的物体的入射角和射出角都是相等的，因而镜面反射物体的法向量因该是垂直于平面的。由于光的粒子性，漫反射物体我们可以认为是由无限多个镜面反射物体所组成的一种复杂物体。根据这些理论，OpenGL在绘制三维物体时将按照给定的顶点法向量值来计算这个面的明暗亮度。计算法向量要用到一个数学基础知识，可能对于一些人来说有些晦涩难懂，不过没有关系，这里有现成的函数，你直接调用就可以计算了：

// 归一化函数，没什么可说的
template <typename Type>
HRESULT ReduceToUnit( Type *pVector )
{
    double dLength = sqrt( (double)pVector[0] * (double)pVector[0] +
        (double)pVector[1] * (double)pVector[1] +
        (double)pVector[2] * (double)pVector[2] );

    if ( FLOATEQUAL( dLength, 0.0, 1e-8 ) )
    {
        dLength = 1.0;
    }
    pVector[0] /= (Type)dLength;
    pVector[1] /= (Type)dLength;
    pVector[2] /= (Type)dLength;
    return S_OK;
}

// 第一个参数用9个double表示一个三角型，三角型的法向量将由第二个参数传出。
template <typename T1, typename T2>
HRESULT CalcNormal( const T1 *pVertical, T2 *pNormal )
{
    T1 d1[3], d2[3];
    d1[0] = pVertical[0] - pVertical[3];
    d1[1] = pVertical[1] - pVertical[4];
    d1[2] = pVertical[2] - pVertical[5];
    d2[0] = pVertical[3] - pVertical[6];
    d2[1] = pVertical[4] - pVertical[7];
    d2[2] = pVertical[5] - pVertical[8];
    pNormal[0] = (T2)( d1[1] * d2[2] - d1[2] * d2[1] );
    pNormal[1] = (T2)( d1[2] * d2[0] - d1[0] * d2[2] );
    pNormal[2] = (T2)( d1[0] * d2[1] - d1[1] * d2[0] );
    return ReduceToUnit( pNormal );
}


问题又出现了，一个顶点可以属于不同的面，但是法向量确只有一个，给个顶点赋任何一个面的法向量都将导致显示不正常，那么我们该怎么办呢？只好按照索引将这些顶点“拆开”。

for ( int i = 0; i < 36; i++ )
{
    // nTempBox是一个临时数组变量，用于保存拆开后的数据。
    MoveMemory( &nTempBox[ i * 3 ], &nSrcBox[ byIndex[i] * 3 ], sizeof(nTempBox[0]) * 3 );
}

下面我们就可以计算法向量了。

for ( int i = 0; i < 12; i++ )
{
    // 跟据一个三角形的三个顶点计算出该三角形的法向量
    CalcNormal( &nTempBox[ i * 9 ], &fNormal[ i * 9 ] );
    // 并把这个法向量赋给这个三角形的三个顶点
    MoveMemory( &fNormal[ i * 9 + 3 ], &fNormal[ i * 9 ], sizeof(fNormal[0]) * 3 );
    MoveMemory( &fNormal[ i * 9 + 6 ], &fNormal[ i * 9 ], sizeof(fNormal[0]) * 3 );
}
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer( 3, GL_SHORT, 0, nTempBox );
glEnableClientState( GL_NORMAL_ARRAY ); // 启用法向量
glNormalPointer( GL_FLOAT, 0, fNormal ); // 填写法向量数组地址

因为用不着索引数组，下面的绘制代码将更加简单：

glDrawArrays( GL_TRIANGLES, 0, 36 );

好了，现在整篇代码应该是这个样子了：

// GlTest.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "GlTest.h"
#define MAX_LOADSTRING 100


// 全局变量：
HINSTANCE hInst; // 当前实例
HWND g_hWnd;
HDC g_hDC;
HGLRC g_glRes;

short nSrcBox[ 3 * 8 ] = {
5, 5, 0, 5, 5, 10,
5, -5, 0, 5, -5, 10,
-5, -5, 0, -5, -5, 10,
-5, 5, 0, -5, 5, 10,
};

BYTE byIndex[36] ={
0, 4, 6, 0, 2, 4,
0, 6, 7, 0, 7, 1,
0, 3, 2, 0, 1, 3,
5, 2, 3, 5, 4, 2,
5, 6, 4, 5, 7, 6,
5, 1, 7, 5, 3, 1,
};

short nTempBox[ 36 * 3 ];
float fNormal[ 36 * 3 ];

TCHAR szTitle[MAX_LOADSTRING]; // 标题栏文本
TCHAR szWindowClass[MAX_LOADSTRING]; // 主窗口类名


template <typename Type>
HRESULT ReduceToUnit( Type *pVector )
{
    double dLength = sqrt( (double)pVector[0] * (double)pVector[0] +
        (double)pVector[1] * (double)pVector[1] +
        (double)pVector[2] * (double)pVector[2] );

    if ( FLOATEQUAL( dLength, 0.0, 1e-8 ) )
    {
        dLength = 1.0;
    }
    pVector[0] /= (Type)dLength;
    pVector[1] /= (Type)dLength;
    pVector[2] /= (Type)dLength;
    return S_OK;
}

template <typename T1, typename T2>
HRESULT CalcNormal( const T1 *pVertical, T2 *pNormal )
{
    T1 d1[3], d2[3];
    d1[0] = pVertical[0] - pVertical[3];
    d1[1] = pVertical[1] - pVertical[4];
    d1[2] = pVertical[2] - pVertical[5];
    d2[0] = pVertical[3] - pVertical[6];
    d2[1] = pVertical[4] - pVertical[7];
    d2[2] = pVertical[5] - pVertical[8];
    pNormal[0] = (T2)( d1[1] * d2[2] - d1[2] * d2[1] );
    pNormal[1] = (T2)( d1[2] * d2[0] - d1[0] * d2[2] );
    pNormal[2] = (T2)( d1[0] * d2[1] - d1[1] * d2[0] );
    return ReduceToUnit( pNormal );
}

// 此代码模块中包含的函数的前向声明：
void OnCreate( HWND hWnd );
void OnCreated( void );
void OnDestroy( void );
void OnDraw( void );
void SetProjMatrix( WORD wWidth, WORD wHeight );
void SetModalMatrix( void );
void OnIdle( void );

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
    // TODO: 在此放置代码。
    MSG msg;
    HACCEL hAccelTable;

    // 初始化全局字符串
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_GLTEST, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化：
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_GLTEST);

    // 主消息循环：
    while ( true )
    {
        if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
        {
            if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            continue;
        }
        if ( WM_QUIT == msg.message )
        {
            break;
        }
        OnIdle();
    }

    return (int) msg.wParam;
}


ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style = 0;
    wcex.lpfnWndProc = (WNDPROC)WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_GLTEST);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName = (LPCTSTR)IDC_GLTEST;
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

    return RegisterClassEx(&wcex);
}

//
// 函数：InitInstance(HANDLE, int)
//
// 目的：保存实例句柄并创建主窗口
//
// 注释：
//
// 在此函数中，我们在全局变量中保存实例句柄并
// 创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // 将实例句柄存储在全局变量中

    CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

    if ( !g_hWnd )
    {
        return FALSE;
    }
    OnCreated();

    ShowWindow( g_hWnd, nCmdShow );
    UpdateWindow( g_hWnd);

    return TRUE;
}

//
// 函数：WndProc(HWND, unsigned, WORD, LONG)
//
// 目的：处理主窗口的消息。
//
// WM_COMMAND - 处理应用程序菜单
// WM_PAINT - 绘制主窗口
// WM_DESTROY - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    switch (message)
    {
    case WM_CREATE:
        OnCreate( hWnd );
        break;
    case WM_KEYDOWN:
        g_bStartSwap = !g_bStartSwap;
        break;
    case WM_MOVE:
        SetWindowText( g_hWnd, "Move" );
        break;
    case WM_COMMAND:
        wmId = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // 分析菜单选择：
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_SIZE:
        SetProjMatrix( LOWORD( lParam ), HIWORD( lParam ) );
        break;
    case WM_DESTROY:
        OnDestroy();
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_INITDIALOG:
        return TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return TRUE;
        }
        break;
    }
    return FALSE;
}

void OnCreate( HWND hWnd )
{
    g_hWnd = hWnd;
}

void OnDestroy( void )
{
    ReleaseDC( g_hWnd, g_hDC );
    wglDeleteContext( g_glRes );
}

void OnCreated( void )
{
    g_hDC = GetDC( g_hWnd );

    PIXELFORMATDESCRIPTOR pfd;
    ZeroMemory( &pfd, sizeof(PIXELFORMATDESCRIPTOR) );
    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR );
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 32;

    SetPixelFormat( g_hDC, ChoosePixelFormat( g_hDC, &pfd ), &pfd );

    g_glRes = wglCreateContext( g_hDC );
    wglMakeCurrent( g_hDC, g_glRes );

    glEnable( GL_CULL_FACE );
    glCullFace( GL_BACK );

    glEnable( GL_DEPTH_TEST );
    glDepthFunc( GL_LEQUAL );

    int LightPos[] = { 50, 50, 10, 1 };
    float LightColor[] = { 0.3f, 0.3f, 0.3f, 1.0f };

    glEnable(GL_LIGHTING);
    glLightiv( GL_LIGHT0, GL_POSITION, LightPos );
    glLightfv( GL_LIGHT0, GL_AMBIENT, LightColor );
    glLightfv( GL_LIGHT0, GL_DIFFUSE, LightColor );
    glEnable( GL_LIGHT0 );
    glEnable( GL_COLOR_MATERIAL );
    glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );

    glShadeModel( GL_SMOOTH );

    glClearColor( 255.0f / 255.0f, 255.0f / 255.0f, 200.0f / 255.0f, 0.0 );
    for ( int i = 0; i < 36; i++ )
    {
        MoveMemory( &nTempBox[ i * 3 ], &nSrcBox[ byIndex[i] * 3 ], sizeof(nTempBox[0]) * 3 );
    }
    for ( int i = 0; i < 12; i++ )
    {
        CalcNormal( &nTempBox[ i * 9 ], &fNormal[ i * 9 ] );
        MoveMemory( &fNormal[ i * 9 + 3 ], &fNormal[ i * 9 ], sizeof(fNormal[0]) * 3 );
        MoveMemory( &fNormal[ i * 9 + 6 ], &fNormal[ i * 9 ], sizeof(fNormal[0]) * 3 );
    }
    glEnableClientState( GL_VERTEX_ARRAY );
    glVertexPointer( 3, GL_SHORT, 0, nTempBox );
    glEnableClientState( GL_NORMAL_ARRAY );
    glNormalPointer( GL_FLOAT, 0, fNormal );

    glColor3ub( 140, 200, 255 );
}

void OnDraw( void )
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glDrawArrays( GL_TRIANGLES, 0, 36 );
    SwapBuffers( g_hDC );
}

void SetModalMatrix( void )
{
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    static float fRadius = 0;
    fRadius += 0.01f;
    if ( fRadius > M_PI * 2 )
    {
        fRadius = 0;
    }
    gluLookAt( cosf( fRadius ) * 30, sinf( fRadius ) * 30, 15.0,
        0.0, 0.0, 0.0,
        0.0, 0.0, 1.0 );
}

void SetProjMatrix( WORD wWidth, WORD wHeight )
{
    glViewport( 0, 0, wWidth, wHeight );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    gluPerspective( 45.0, (double)wWidth / (double)wHeight, 1.0, 1000.0 );
}

void OnIdle( void )
{
    SetModalMatrix();
    OnDraw();
}