积累系统性知识
积聚技术精华
  首页    个人中心    撰写积文    建立课题    订立目标    整理积文    管理课题    管理目标    技能Get    代码积累 
一个极好的OpenGL汉字显示类
error997 (error997)    2014-11-20 20:21:07      目标    课题
   一个极好的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);
        DeleteObject( hbitmap );
    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);                            // 退出程序
}


转自 http://blog.csdn.net/y___y/article/details/1434037
(+0)技能Get

建议楼主:搜索关键字 |参考其他资源 |回复 |追问
  error997(error997):   个人中心    课题    目标    代码积累