一个极好的OpenGL汉字显示类(转,作者Y_Y)

一个极好的OpenGL汉字显示类
作者：Y___Y
联系： yinwei_88@sina.com
    笔者通过各方面的资料的收集，终于写出了一个OpenGL汉字显示类（最核心的内容都是从网上和NeHe的教程上找到的，这个类实际上是从各位原创作者“集合”成的，笔者只能算一个收集整理者），很好的解决了2D，3D以及图象，图形汉字（当然也包括字母）的显示。现将其公布出来。

 

// GLFont.h文件
#include  < windows.h >
#include  " gl/gl.h "
#pragma  warning(disable:4244)
// OpenGL汉字显示类
class  GLfont
... {
    HFONT hFont;
    COLORREF cl;
public:
    GLfont();
    virtual ~GLfont();
    void SetTextColor(COLORREF textcolor);//字体颜色设置
    void CreateFont(char *facename, int height, int weight, bool italic,bool underline,bool strikeout);
    void ShowText(int x, int y, LPCTSTR lpszText);//显示图象2D汉字
    void Show2DText(char *str);//显示图形2D汉字
    void Show3DText(unsigned char *str);//显示图形3D汉字
} ;

GLfont::GLfont()
... {
    cl=RGB(255,255,255);
}
GLfont:: ~ GLfont()
... {
    if(hFont) DeleteObject(hFont);
}

// 只有关闭光照和纹理才能正确显示颜色
void  GLfont::SetTextColor(COLORREF textcolor) // 字体颜色设置
... {
    cl=textcolor;
}
void  GLfont::CreateFont( char   * facename,  int  height,  int  weight,  bool  italic, bool  underline, bool  strikeout)
... {
    LOGFONT lf;
    lf.lfHeight = height;
    lf.lfWidth = 0;
    lf.lfEscapement = 0;
    lf.lfOrientation = 0;
    lf.lfWeight = weight;
    lf.lfItalic = italic;
    lf.lfUnderline = underline;
    lf.lfStrikeOut = strikeout;
    lf.lfCharSet = DEFAULT_CHARSET;
    lf.lfOutPrecision = OUT_TT_PRECIS;
    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf.lfQuality = PROOF_QUALITY;
    lf.lfPitchAndFamily = VARIABLE_PITCH | TMPF_TRUETYPE | FF_MODERN;
    strcpy(lf.lfFaceName,facename);
    // 创建字体
    hFont = CreateFontIndirect(&lf);
}

// 2D图像汉字只与屏幕相联系，与具体的变换矩阵无关，也就是说不能缩放旋转。
// x,y是2D图像汉字距屏幕左下角（注意不是左上角）的横向和纵向距离。
void  GLfont::ShowText( int  x,  int  y, LPCTSTR lpszText)
... {
    // 保存原投影矩阵，将投影矩阵设为平行投影
    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadIdentity();
    glOrtho( 0, 640, 0, 480, -1, 1 );
    // 保存原模型变换矩阵，平移至( x, y )
    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadIdentity();
    RECT rect;
    GetClientRect(GetActiveWindow(),&rect);
    glTranslatef((float)x,(float)y,0);
    HBITMAP hbitmap;
    BITMAP bm;
    SIZE size;
    UCHAR* pBmpBits;
    HFONT hOldFont;
    HDC hdc = wglGetCurrentDC();
    hOldFont = (HFONT)SelectObject(hdc, hFont);
    ::GetTextExtentPoint32(hdc, lpszText, strlen(lpszText), &size);
    hbitmap = CreateBitmap(size.cx, size.cy,1, 1, NULL);
    HDC hMemDC = ::CreateCompatibleDC(hdc);
    if(hMemDC)
    ...{
        HBITMAP hPrevBmp = (HBITMAP)SelectObject(hMemDC,hbitmap);
        HFONT hPrevFont = (HFONT)SelectObject(hMemDC, hFont);
        SetBkColor(hMemDC, RGB(0, 0, 0));
        ::SetTextColor(hMemDC,RGB(255,255,255));
        SetBkMode(hMemDC, OPAQUE);
        TextOut(hMemDC, 0, 0, lpszText, strlen(lpszText));
        //把GDI位图复制到DIB
        SelectObject(hdc,hbitmap);
        GetObject(hbitmap, sizeof(bm), &bm);
        size.cx = (bm.bmWidth + 31) & (~31);
        size.cy = bm.bmHeight;
        int bufsize = size.cy * (((bm.bmWidth + 31) & (~31)) /8);
        pBmpBits = new UCHAR[bufsize];
        memset(pBmpBits, 0, sizeof(UCHAR)*bufsize);
        struct
        ...{
            BITMAPINFOHEADER bih;
            RGBQUAD col[2];
        }
        bic;
        BITMAPINFO *binf = (BITMAPINFO *)&bic;
        binf->bmiHeader.biSize = sizeof(binf->bmiHeader);
        binf->bmiHeader.biWidth = bm.bmWidth;
        binf->bmiHeader.biHeight = bm.bmHeight;
        binf->bmiHeader.biPlanes = 1;
        binf->bmiHeader.biBitCount = 1;
        binf->bmiHeader.biCompression = BI_RGB;
        binf->bmiHeader.biSizeImage = bufsize;
        binf->bmiHeader.biXPelsPerMeter = 1;
        binf->bmiHeader.biYPelsPerMeter = 1;
        binf->bmiHeader.biClrUsed = 0;
        binf->bmiHeader.biClrImportant = 0;
        ::GetDIBits(hdc, hbitmap, 0, bm.bmHeight, pBmpBits, binf,DIB_RGB_COLORS);
        SelectObject(hMemDC,hPrevBmp);
    }
    ::DeleteDC(hMemDC);
    SelectObject(hdc, hOldFont);
    
    //显示文字
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glColor3f(GetRValue(cl)/255.0,GetGValue(cl)/255.0,GetBValue(cl)/255.0);
    glRasterPos2i(x,y);
    glBitmap(size.cx, size.cy, 0.0, 2.0, size.cx+2.0f, 0.0, pBmpBits);
    delete pBmpBits;
    // 恢复投影矩阵和模型变换矩阵
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glColor3f(1.0,1.0,1.0);
}

void  GLfont::Show2DText( char   * str)
... {
    char FTextList[255];
    GLYPHMETRICSFLOAT gmf[256];
    int m_iCount=strlen(str);    
    GLuint m_listbase;
    HDC hDC=wglGetCurrentDC();
    glPushMatrix();
    
    SelectObject(hDC,hFont);
    int  i=0; 
    int  j=0; 
    int ich,cch;
    m_listbase = glGenLists(256);
    glColor3f(GetRValue(cl)/255.0,GetGValue(cl)/255.0,GetBValue(cl)/255.0);
    while(i<m_iCount)
    ...{
        if(IsDBCSLeadByte(str[i]))
        ...{ 
            //判断是否为双字节 
            ich=str[i]; 
            ich=(ich<<8)+256; /**/////256为汉字内码“偏移量” 
            ich=ich+str[i+1]; 
            i++;i++; 
            wglUseFontOutlines(hDC,//字体轮廓设备联系DC 
                ich, //要转换为显示列表的第一个字符 
                1, //要转换为显示列表的字符数 
                m_listbase+j,//显示列表的基数 
                1.0f, //指定与实际轮廓的最大偏移量 
                0,//0.15f, //在Z轴负方向的值 
                WGL_FONT_POLYGONS, //指定显示列表线段或多边形 
                &gmf[j]); //接受字符的地址 
            FTextList[j]=j; 
            j++; 
            
        }
        else
        ...{ 
            cch=str[i]; 
            i++; 
            wglUseFontOutlines(hDC, //字体轮廓设备联系DC 
                cch,//要转换为显示列表的第一个字符 
                1,//要转换为显示列表的字符数 
                m_listbase+j,//显示列表的基数 
                0.0f,//指定与实际轮廓的最大偏移量 
                0.0,//0.15f,//在Z轴负方向的值 
                WGL_FONT_POLYGONS, //指定显示列表线段或多边形 
                &gmf[j]);//接受字符的地址 
            FTextList[j]=j;
            j++;
        } 
    } 
    
    glPushAttrib(GL_LIST_BIT);
    ...{
        glListBase(m_listbase);
        glCallLists(m_iCount, GL_UNSIGNED_BYTE, &FTextList);
    }
    glPopAttrib();
    glPopMatrix();
    glColor3f(1.0,1.0,1.0);
}
void  GLfont::Show3DText(unsigned  char   * str)
... {
    glPushMatrix();
    GLYPHMETRICSFLOAT pgmf[1];

    HDC hDC=wglGetCurrentDC();
    //设置当前字体 
    SelectObject(wglGetCurrentDC(),hFont); 

    DWORD dwChar;
    int ListNum;
    for(size_t i=0;i<strlen((char *)str);i++)
    ...{
        if(IsDBCSLeadByte(str[i]))
        ...{
            dwChar=(DWORD)((str[i]<<8)|str[i+1]);
            i++;
        }
        else 
            dwChar=str[i];
        ListNum=glGenLists(1);
        glColor3f(GetRValue(cl)/255.0,GetGValue(cl)/255.0,GetBValue(cl)/255.0);
        wglUseFontOutlines(hDC,dwChar,1,ListNum,0.0,0.1f,WGL_FONT_POLYGONS,pgmf);
        glCallList(ListNum);
        glDeleteLists(ListNum,1);
    }
    glPopMatrix();
    glColor3f(1.0,1.0,1.0);
}

显示效果

 

程序完整的源代码

 

#include  < windows.h >          //  Windows的头文件
#include  < GL / gl.h >          //  包含最新的gl.h,glu.h库
#include  < GL / glu.h >          //  包含OpenGL实用库
#include  < GL / glaux.h >
#include  < stdio.h >           //  标准输入/输出库的头文件
#include  < math.h >
#define  D_PI 3.141592653        
#include  " GLFont.h "        // 引入OpenGL汉字显示类文件
#pragma  warning(disable:4305)
#pragma  warning(disable:4244)

HDC            hDC = NULL;         //  窗口着色描述表句柄
HGLRC        hRC = NULL;         //  OpenGL渲染描述表句柄
HWND        hWnd = NULL;         //  保存我们的窗口句柄
HINSTANCE    hInstance;         //  保存程序的实例

bool  keys[ 256 ];             //  保存键盘按键的数组
bool  active = TRUE;         //  窗口的活动标志，缺省为TRUE
bool  fullscreen = TRUE;     //  全屏标志缺省，缺省设定成全屏模式
LRESULT    CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);     //  WndProc的定义

BOOL light;                                     //  光源的开/关
bool  lp;
GLfloat LightAmbient[] = ... {0.5f,0.5f,0.5f,1.0f} ; 
GLfloat LightDiffuse[] = ... {1.0f,1.0f,1.0f,1.0f} ;
GLfloat LightPosition[] = ... {0.0f,0.0f,2.0f,1.0f} ;
GLuint    texture[ 3 ];
GLfont f;
AUX_RGBImageRec  * LoadBMP( char   * Filename)                     //  载入位图图象
... {
    FILE *File=NULL;                            // 文件句柄
    if(!Filename)                                // 确保文件名已提供
    ...{
        return NULL;                            // 如果没提供，返回 NULL
    }
    File=fopen(Filename,"r");                        // 尝试打开文件
    if(File)                                // 文件存在么?
    ...{
        fclose(File);                            // 关闭句柄
        return auxDIBImageLoad(Filename);                // 载入位图并返回指针
    }
    return NULL;                                // 如果载入失败，返回 NULL
}
int  LoadGLTextures()                                 //  载入位图(调用上面的代码)并转换成纹理
... {
    int Status=FALSE;                            // 状态指示器
    AUX_RGBImageRec *TextureImage[1];                    // 创建纹理的存储空间
    memset(TextureImage,0,sizeof(void *)*1);                // 将指针设为 NULL
    // 载入位图，检查有无错误，如果位图没找到则退出
    if(TextureImage[0]=LoadBMP("Data/NeHe.bmp"))
    ...{
        Status=TRUE;                            // 将 Status 设为 TRUE
        glGenTextures(3, &texture[0]);                    // 创建纹理
        
        // 创建 Nearest 滤波贴图
        glBindTexture(GL_TEXTURE_2D, texture[0]);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); 
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); 
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
        // 创建线性滤波纹理
        glBindTexture(GL_TEXTURE_2D, texture[1]);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
        // 创建 MipMapped 纹理
        glBindTexture(GL_TEXTURE_2D, texture[2]);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST); 
        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data); 
    }
    if (TextureImage[0])                            // 纹理是否存在
    ...{
        if (TextureImage[0]->data)                    // 纹理图像是否存在
        ...{
            free(TextureImage[0]->data);                // 释放纹理图像占用的内存
        }        
        free(TextureImage[0]);                        // 释放图像结构
    }
    return Status;                                // 返回 Status
}


GLvoid ReSizeGLScene(GLsizei width, GLsizei height)         //  重置OpenGL窗口大小
... {
    if (height==0)                                        // 防止被零除
    ...{
        height=1;                                        // 将Height设为1
    }

    glViewport(0,0,width,height);                        // 重置当前的视口

    glMatrixMode(GL_PROJECTION);                        // 选择投影矩阵
    glLoadIdentity();                                    // 重置投影矩阵

    // 设置视口的大小
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

    glMatrixMode(GL_MODELVIEW);                            // 选择模型观察矩阵
    glLoadIdentity();                                    // 重置模型观察矩阵
}

GLfloat mat_ambient[] =   ... { 0.8, 0.8, 0.8, 1.0 } ;
GLfloat mat_diffuse[] =   ... { 0.8, 0.0, 0.8, 1.0 } ; /**/ /* 紫色 */
GLfloat mat_specular[]  =   ... { 1.0, 0.0, 1.0, 1.0 } ;
GLfloat mat_shininess[]  =   ... { 100.0 } ;

int  InitGL(GLvoid)                                     //  此处开始对OpenGL进行所有设置
... {
    //glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); //启用双面光照
    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);    
    glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);
    glEnable(GL_LIGHT1);

    f.CreateFont("隶书",80,80,0,0,0);    
    if(!LoadGLTextures())
    ...{
        return false;
    }
    glEnable(GL_TEXTURE_2D);

    glShadeModel(GL_SMOOTH);                            // 启用阴影平滑

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);                // 黑色背景
    glClearDepth(1.0f);                                    // 设置深度缓存
    glEnable(GL_DEPTH_TEST);                            // 启用深度测试
    glDepthFunc(GL_LEQUAL);                                // 所作深度测试的类型
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);    // 告诉系统对透视进行修正

    //glPolygonMode( GL_BACK, GL_LINE);            // 后表面完全填充
    //glPolygonMode( GL_FRONT, GL_FILL);            // 前表面使用线条绘制
    return TRUE;                                        // 初始化 OK
}

int  DrawGLScene(GLvoid)                                     //  从这里开始进行所有的绘制
... {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // 清除屏幕和深度缓存

    glLoadIdentity();

    glTranslatef(0,0,-6.0);

    static float rz=0.0;
    glRotatef(rz,0.0,1.0,0.0);//旋转显示
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    glEnable(GL_TEXTURE_GEN_S);                // 使用自动生成纹理
    glEnable(GL_TEXTURE_GEN_T);    

/**///字体显示的各种方法///
    //图像文字效果
    glPushMatrix();
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    f.SetTextColor(RGB(255,255,0));
    f.ShowText(100,100,"我爱OpenGL!");
    glEnable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glPopMatrix();

    //带材质的2D文字效果
    glPushMatrix();
    glDisable(GL_TEXTURE_2D);
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glTranslatef(-3,1.5,0);
    glRotatef(30,1,1,0);
    f.Show2DText("我爱OpenGL!");
    glEnable(GL_TEXTURE_2D);
    glPopMatrix();

    //带纹理的3D文字效果
    glPushMatrix();
    //glDisable(GL_TEXTURE_2D);
    //glDisable(GL_LIGHTING);
    glTranslatef(-3,0.5,0);
    glRotatef(30,1,1,0);
    f.SetTextColor(RGB(255,0,0));
    f.Show3DText((unsigned char*)"我爱OpenGL!");
    //glEnable(GL_LIGHTING);
    //glEnable(GL_TEXTURE_2D);
    glPopMatrix();

    //超酷的金属质感纹理效果
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glPushMatrix();
    //glDisable(GL_TEXTURE_2D);
    //glDisable(GL_LIGHTING);
    glTranslatef(-3,-0.5,0);
    glRotatef(30,1,1,0);
    f.SetTextColor(RGB(255,0,0));
    f.Show3DText((unsigned char*)"我爱OpenGL!");
    //glEnable(GL_LIGHTING);
    //glEnable(GL_TEXTURE_2D);
    glPopMatrix();

    rz+=1.0;
    Sleep(20);
    return TRUE;                                        // 一切 OK
}

GLvoid KillGLWindow(GLvoid)                                 //  正常销毁窗口
... {
    if (fullscreen)                                        // 我们处于全屏模式吗?
    ...{
        ChangeDisplaySettings(NULL,0);                    // 是的话，切换回桌面
        ShowCursor(TRUE);                                // 显示鼠标指针
    }

    if(hRC)                                            //我们拥有OpenGL描述表吗?
    ...{
        if(!wglMakeCurrent(NULL,NULL))                    // 我们能否释放DC和RC描述表?
        ...{
            MessageBox(NULL,"释放DC或RC失败。","关闭错误",MB_OK | MB_ICONINFORMATION);
        }

        if(!wglDeleteContext(hRC))                        // 我们能否删除RC?
        ...{
            MessageBox(NULL,"释放RC失败。","关闭错误",MB_OK | MB_ICONINFORMATION);
        }
        hRC=NULL;                                        // 将RC设为 NULL
    }

    if(hDC&&!ReleaseDC(hWnd,hDC))                    // 我们能否释放 DC?
    ...{
        MessageBox(NULL,"释放DC失败。","关闭错误",MB_OK | MB_ICONINFORMATION);
        hDC=NULL;                                        // 将 DC 设为 NULL
    }

    if(hWnd && !DestroyWindow(hWnd))                    // 能否销毁窗口?
    ...{
        MessageBox(NULL,"释放窗口句柄失败。","关闭错误",MB_OK | MB_ICONINFORMATION);
        hWnd=NULL;                                        // 将 hWnd 设为 NULL
    }

    if (!UnregisterClass("OpenG",hInstance))            // 能否注销类?
    ...{
        MessageBox(NULL,"不能注销窗口类。","关闭错误",MB_OK | MB_ICONINFORMATION);
        hInstance=NULL;                                    // 将 hInstance 设为 NULL
    }
}

/**/ /*    这个函数创建我们OpenGL窗口，参数为：                                    *
 *    title            - 窗口标题                                                *
 *    width            - 窗口宽度                                                *
 *    height            - 窗口高度                                                *
 *    bits            - 颜色的位深（8/16/32）                                    *
 *    fullscreenflag    - 是否使用全屏模式，全屏模式(TRUE)，窗口模式(FALSE)        */
 
BOOL CreateGLWindow( char *  title,  int  width,  int  height,  int  bits,  bool  fullscreenflag)
... {
    GLuint        PixelFormat;            // 保存查找匹配的结果
    WNDCLASS    wc;                        // 窗口类结构
    DWORD        dwExStyle;                // 扩展窗口风格
    DWORD        dwStyle;                // 窗口风格
    RECT        WindowRect;                // 取得矩形的左上角和右下角的坐标值
    WindowRect.left=(long)0;            // 将Left   设为 0
    WindowRect.right=(long)width;        // 将Right  设为要求的宽度
    WindowRect.top=(long)0;                // 将Top    设为 0
    WindowRect.bottom=(long)height;        // 将Bottom 设为要求的高度

    fullscreen=fullscreenflag;            // 设置全局全屏标志

    hInstance            = GetModuleHandle(NULL);                // 取得我们窗口的实例
    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;    // 移动时重画，并为窗口取得DC
    wc.lpfnWndProc        = (WNDPROC) WndProc;                    // WndProc处理消息
    wc.cbClsExtra        = 0;                                    // 无额外窗口数据
    wc.cbWndExtra        = 0;                                    // 无额外窗口数据
    wc.hInstance        = hInstance;                            // 设置实例
    wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);            // 装入缺省图标
    wc.hCursor            = LoadCursor(NULL, IDC_ARROW);            // 装入鼠标指针
    wc.hbrBackground    = NULL;                                    // GL不需要背景
    wc.lpszMenuName        = NULL;                                    // 不需要菜单
    wc.lpszClassName    = "OpenG";                                // 设定类名字

    if (!RegisterClass(&wc))                                    // 尝试注册窗口类
    ...{
        MessageBox(NULL,"注册窗口失败","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                    // 退出并返回FALSE
    }
    
    if (fullscreen)                                            // 要尝试全屏模式吗?
    ...{
        DEVMODE dmScreenSettings;                                // 设备模式
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));    // 确保内存清空为零
        dmScreenSettings.dmSize=sizeof(dmScreenSettings);        // Devmode 结构的大小
        dmScreenSettings.dmPelsWidth    = width;                // 所选屏幕宽度
        dmScreenSettings.dmPelsHeight    = height;                // 所选屏幕高度
        dmScreenSettings.dmBitsPerPel    = bits;                    // 每象素所选的色彩深度
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

        // 尝试设置显示模式并返回结果。注: CDS_FULLSCREEN 移去了状态条
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
        ...{
            // 若模式失败，提供两个选项：退出或在窗口内运行。
            if (MessageBox(NULL,"全屏模式在当前显卡上设置失败！使用窗口模式？","NeHe G",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
            ...{
                //如果用户选择窗口模式，变量fullscreen 的值变为FALSE,程序继续运行
                fullscreen=FALSE;        // 选择窗口模式(Fullscreen=FALSE)
            }
            else
            ...{
                //如果用户选择退出，弹出消息窗口告知用户程序将结束。并返回FALSE告诉程序窗口未能成功创建。程序退出。
                MessageBox(NULL,"程序将被关闭","错误",MB_OK|MB_ICONSTOP);
                return FALSE;                                    // 退出并返回 FALSE
            }
        }
    }

    if (fullscreen)                                                // 仍处于全屏模式吗?
    ...{
        dwExStyle=WS_EX_APPWINDOW;                                // 扩展窗体风格
        dwStyle=WS_POPUP;                                        // 窗体风格
        ShowCursor(FALSE);                                        // 隐藏鼠标指针
    }
    else
    ...{
        dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;            // 扩展窗体风格
        dwStyle=WS_OVERLAPPEDWINDOW;                            // 窗体风格
    }

    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);        // 调整窗口达到真正要求的大小

    // 创建窗口
    if (!(hWnd=CreateWindowEx(    dwExStyle,                            // 扩展窗体风格
                                "OpenG",                            // 类名字
                                title,                                // 窗口标题
                                dwStyle |                            // 必须的窗体风格属性
                                WS_CLIPSIBLINGS |                    // 必须的窗体风格属性
                                WS_CLIPCHILDREN,                    // 必须的窗体风格属性
                                0, 0,                                // 窗口位置
                                WindowRect.right-WindowRect.left,    // 计算调整好的窗口宽度
                                WindowRect.bottom-WindowRect.top,    // 计算调整好的窗口高度
                                NULL,                                // 无父窗口
                                NULL,                                // 无菜单
                                hInstance,                            // 实例
                                NULL)))                                // 不向WM_CREATE传递任何东东
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"窗口创建错误","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    static    PIXELFORMATDESCRIPTOR pfd=                //pfd 告诉窗口我们所希望的东东，即窗口使用的像素格式
    ...{
        sizeof(PIXELFORMATDESCRIPTOR),                // 上述格式描述符的大小
        1,                                            // 版本号
        PFD_DRAW_TO_WINDOW |                        // 格式支持窗口
        PFD_SUPPORT_OPENGL |                        // 格式必须支持OpenGL
        PFD_DOUBLEBUFFER,                            // 必须支持双缓冲
        PFD_TYPE_RGBA,                                // 申请 RGBA 格式
        bits,                                        // 选定色彩深度
        0, 0, 0, 0, 0, 0,                            // 忽略的色彩位
        0,                                            // 无Alpha缓存
        0,                                            // 忽略Shift Bit
        0,                                            // 无累加缓存
        0, 0, 0, 0,                                    // 忽略聚集位
        16,                                            // 16位 Z-缓存 (深度缓存) 
        0,                                            // 无蒙板缓存
        0,                                            // 无辅助缓存
        PFD_MAIN_PLANE,                                // 主绘图层
        0,                                            // 不使用重叠层
        0, 0, 0                                        // 忽略层遮罩
    };
    
    if (!(hDC=GetDC(hWnd)))                            // 取得设备描述表了么?
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"不能创建一个窗口设备描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))    // Windows 找到相应的象素格式了吗?
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"不能创建一种相匹配的像素格式","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    if(!SetPixelFormat(hDC,PixelFormat,&pfd))        // 能够设置象素格式么?
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"不能设置像素格式","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    if (!(hRC=wglCreateContext(hDC)))                // 能否取得OpenGL渲染描述表?
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"不能创建OpenGL渲染描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    if(!wglMakeCurrent(hDC,hRC))                    // 尝试激活着色描述表
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"不能激活当前的OpenGL渲然描述表","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    ShowWindow(hWnd,SW_SHOW);                        // 显示窗口
    SetForegroundWindow(hWnd);                        // 略略提高优先级
    SetFocus(hWnd);                                    // 设置键盘的焦点至此窗口
    ReSizeGLScene(width, height);                    // 设置透视 GL 屏幕

    if (!InitGL())                                    // 初始化新建的GL窗口
    ...{
        KillGLWindow();                                // 重置显示区
        MessageBox(NULL,"初始化失败","错误",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // 返回 FALSE
    }

    return TRUE;                                    // 成功
}

LRESULT CALLBACK WndProc(    HWND    hWnd,             //  窗口的句柄    
                            UINT    uMsg,             //  窗口的消息
                            WPARAM    wParam,             //  附加的消息内容
                            LPARAM    lParam)             //  附加的消息内容
... {
    switch (uMsg)                                    // 检查Windows消息
    ...{
        case WM_ACTIVATE:                            // 监视窗口激活消息
        ...{
            if (!HIWORD(wParam))                    // 检查最小化状态
            ...{
                active=TRUE;                        // 程序处于激活状态
            }
            else
            ...{
                active=FALSE;                        // 程序不再激活
            }

            return 0;                                // 返回消息循环
        }

        case WM_SYSCOMMAND:                            // 系统中断命令
        ...{
            switch (wParam)                            // 检查系统调用
            ...{
                case SC_SCREENSAVE:                    // 屏保要运行?
                case SC_MONITORPOWER:                // 显示器要进入节电模式?
                return 0;                            // 阻止发生
            }
            break;                                    // 退出
        }

        case WM_CLOSE:                                // 收到Close消息?
        ...{
            PostQuitMessage(0);                        // 发出退出消息
            return 0;                                // 返回
        }

        case WM_KEYDOWN:                            // 有键按下么?
        ...{
            keys[wParam] = TRUE;                    // 如果是，设为TRUE
            return 0;                                // 返回
        }

        case WM_KEYUP:                                // 有键放开么?
        ...{
            keys[wParam] = FALSE;                    // 如果是，设为FALSE
            return 0;                                // 返回
        }

        case WM_SIZE:                                // 调整OpenGL窗口大小
        ...{
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width,HiWord=Height
            return 0;                                // 返回
        }
    }

    // 向 DefWindowProc传递所有未处理的消息。
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int  WINAPI WinMain(HINSTANCE    hInstance,             //  当前窗口实例
                    HINSTANCE    hPrevInstance,         //  前一个窗口实例
                    LPSTR        lpCmdLine,             //  命令行参数
                     int             nCmdShow)             //  窗口显示状态
... {
    MSG        msg;                                    // Windowsx消息结构
    BOOL    done=FALSE;                                // 用来退出循环的Bool 变量

    // 提示用户选择运行模式
    if (MessageBox(NULL,"你想在全屏模式下运行么？", "设置全屏模式",MB_YESNO|MB_ICONQUESTION)==IDNO)
    ...{
        fullscreen=FALSE;                            // FALSE为窗口模式
    }

    // 创建OpenGL窗口
    if (!CreateGLWindow("NeHe's OpenGL 程序框架",640,480,16,fullscreen))
    ...{
        return 0;                                    // 失败退出
    }

    while(!done)                                    // 保持循环直到 done=TRUE
    ...{
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))    // 有消息在等待吗?
        ...{
            if (msg.message==WM_QUIT)                // 收到退出消息?
            ...{
                done=TRUE;                            // 是，则done=TRUE
            }
            else                                    // 不是，处理窗口消息
            ...{
                TranslateMessage(&msg);                // 翻译消息
                DispatchMessage(&msg);                // 发送消息
            }
        }
        else                                        // 如果没有消息
        ...{
            // 绘制场景。监视ESC键和来自DrawGLScene()的退出消息
            if (active)                                // 程序激活的么?
            ...{
                if (keys[VK_ESCAPE])                // ESC 按下了么?
                ...{
                    done=TRUE;                        // ESC 发出退出信号
                }
                else                                // 不是退出的时候，刷新屏幕
                ...{
                    DrawGLScene();                    // 绘制场景
                    SwapBuffers(hDC);                // 交换缓存 (双缓存)
                    if (keys['L'] && !lp)                // L 键已按下并且松开了?
                    ...{
                        lp=TRUE;                // lp 设为 TRUE
                        light=!light;                // 切换光源的 TRUE/FALSE
                        if (!light)                // 如果没有光源
                        ...{
                            glDisable(GL_LIGHTING);        // 禁用光源
                        }
                        else                    // 否则
                        ...{
                            glEnable(GL_LIGHTING);        // 启用光源
                        }
                    }
                    if (!keys['L'])                    // L键松开了么?
                    ...{
                        lp=FALSE;                // 若是，则将lp设为FALSE
                    }
                }
            }

            if (keys[VK_F1])                        // F1键按下了么?
            ...{
                keys[VK_F1]=FALSE;                    // 若是，使对应的Key数组中的值为 FALSE
                KillGLWindow();                        // 销毁当前的窗口
                fullscreen=!fullscreen;                // 切换 全屏 / 窗口 模式
                // 重建 OpenGL 窗口
                if (!CreateGLWindow("NeHe's OpenGL 程序框架",640,480,16,fullscreen))
                ...{
                    return 0;                // 如果窗口未能创建，程序退出
                }
            }
        }
    }

    // 关闭程序
    KillGLWindow();                                    // 销毁窗口
    return (msg.wParam);                            // 退出程序
}