opengl纹理,光照,glColor4f(),混合-蒲公英云

glColor4f()与光照是平级的,且两者互斥,水火不容,有我没你.对于纹理图片中的某个像素P(r,g,b,1):

（1）如果有光照L(Lr,Lg,Lb,x),则glColor4f(Cr,Cg,cb,Calpha)无用,像素P应该只乘以光照L,则像素P的实际颜色P1=P*L＝(r*Lr,g*Lg,b*Lb,1)；（注：P1的alpha恒为1，无须乘以光照的alpha值，即光照的alpha值在此处无用。下面的程序中可验证，无论x取何值，都对结果无影响）。

（2）如果无光照,则glColor4f(Cr,Cg,cb,Calpha)有效,则P1=P*C=( r*Cr,g*Cg,b*Cb,Calpha).如果还有混合的话,则P1再按alpha比例与以前的点混合.

总结：

（1）有光照时：像素点最终颜色P1的alpha恒为1，P1的RGB=像素RGB*光照RGB。

（2）无光照时：像素点最终颜色P1的alpha为glColor4f()的alpha值，P1的RGB=像素RGB*glColor4f()的RGB。

可以通过下面的程序来验证结果(可用QQ截图查看最终显示图的像素).

代码如下(摘自nehe的opengl教程-07-灯光,且可在DrawGLScene()函数内更改混合状态(glEnable(GL_BLEND) 或者glDisable(GL_BLEND)),程序运行后按大写的L可打开/关闭光源,且为了便于计算,我把纹理图片.bmp特意做成背景为白色,里面有几个红色,绿色,和像素为100的小方框):

其中,opengl默认背景glClearColor(0.6,0.6,0.6),光照值为(0.4,0.4,0.4,x),待检验的像素为100，即(100/255,100/255,100/255),设r=100/255,无光照时glColor4f(0.2,0.2,0.2,0.1)的alpha=0.1：

一、如果混合方式为glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)：

（1）无光源:则glColor4f(0.2,0.2,0.2,0.1)有效,所以像素P的实际颜色为

P1=背景色RGB*对应alpha+像素色RGB*glColor4f颜色RGB*对应alpha

=(0.6,0.6,0.6)*0.9+(100/255,100/255,100/255)*(0.2,0.2,0.2)*0.1

=(0.6*0.9,0.6*0.9,0.6*0.9)+(100/255 *0.2*0.1,100/255 *0.2*0.1,100/255 *0.2*0.1)，各乘以255后为(140, 140, 140)；

（2）有光源:则glColor4f()无效,所以像素P的实际颜色为

P1=背景色RGB*对应alpha +像素色RGB*光照颜色RGB*对应alpha

=(0.6,0.6,0.6)*0+(100/255,100/255,100/255)*( 0.4,0.4,0.4)*1

=(0.6*0,0.6*0,0.6*0)+(100/255 *0.4* 1,100/255 *0.4* 1,100/255 *0.4* 1)，各乘以255后为(40, 40, 40)。

二、如果混合方式为glBlendFunc(GL_SRC_ALPHA, GL_ONE);即已画的(目标)不变,再加上要画的源):

(1)无光源:则glColor4f(0.2,0.2,0.2,0.1)有效,所以像素P的实际颜色为

P1=背景色RGB*对应alpha+像素色RGB*glColor4f颜色RGB*对应alpha

=(0.6,0.6,0.6)*1+(100/255,100/255,100/255)*(0.2,0.2,0.2)*0.1

=(0.6,0.6,0.6)+(100/255 *0.2*0.1,100/255 *0.2*0.1,100/255 *0.2*0.1)，各乘以255后为(155, 155, 155)；

(2)有光源:则glColor4f()无效,所以像素P的实际颜色为

P1=背景色RGB*对应alpha +像素色RGB*光照颜色RGB*对应alpha

=(0.6,0.6,0.6)*1+(100/255,100/255,100/255)*( 0.4,0.4,0.4)*1

=(0.6,0.6,0.6)+(100/255 *0.4* 1,100/255 *0.4* 1,100/255 *0.4* 1)，各乘以255后为(193, 193, 193)。

三、如果混合方式为glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);则与glBlendFunc(GL_SRC_ALPHA, GL_ONE);的结果一样，这表示，帧缓存中像素的alpha值就是1。

四、而上面有无光照的2种情况，在无混合时，无需乘以对应的alpha：

（1）无光源:则glColor4f(0.2,0.2,0.2,0.1)有效,所以像素P的实际颜色为P1=像素色RGB*glColor4f颜色RGB=(100/255,100/255,100/255)*(0.2,0.2,0.2)

=(100/255* 0.2, 100/255* 0.2, 100/255* 0.2)，各乘以255后为(20, 20, 20）；

（2）有光源:则glColor4f()无效,所以像素像素P的实际颜色为P1=像素色RGB*光照颜色RGB= (100/255,100/255,100/255)*( 0.4,0.4,0.4)

=(100/255* 0.4, 100/255* 0.4, 100/255* 0.4) ，各乘以255后为(40, 40, 40）。

验证时，为简化，可只检验一个颜色，如颜色(r,g,b)的r值。

下面这段代码可控制光源中只有全局环境光(为(0.4,0.4,0.4,0.7)),这样在计算某个点的光照,混合,纹理时可把光照值定下来(此处为(0.4,0.4,0.4, 0.7)),再确定其他操作(如混合)以像素产生的效果.

注：顶点光照值为：自发散光+全局环境光+光源环境光+散射光+镜面光＝

Emission+ LIGHT_MODEL_AMBIENT+ Ambient+ Diffuse+ Specular

(此处只有全局环境光(0.4,0.4,0.4, 0.7))

且结果与全局环境光的alpha值0.7无关。即当前点的alpha值与光照的alpha值是无关的。

GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };

GLfloat mat_diffuse[] = { 0.0, 0.0, 0.0, 1.0 };//无散射光

GLfloat mat_emission[] = { 0.0, 0.0, 0.0, 1.0 };//无自发散光

GLfloat mat_specular[] = { 0.4, 0.4, 0.4, 1.0 };//

GLfloat mat_shininess[] = { 2.0 };

GLfloat LightPosition[] = { 1.0, 1.0, 1.0, 1.0 };//点光源(位置性光源)

GLfloat LightAmbient[] = { 0.0, 0.0, 0.0, 1.0};//无光源的环境光

GLfloat LightDiffuse[] = {1.0, 1.0, 1.0, 1.0};

GLfloat light_specular[] ={ 0.0, 0.0, 0.0, 1.0};//无镜面光

GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 0.7};//只有全局环境光

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_EMISSION, mat_emission);

glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

glLightfv(GL_LIGHT0, GL_POSITION, LightPosition);//点光源相对视点的位置始终不变,此处是(1,1,1)

glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);

glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);

glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);//全局环境光

glEnable(GL_LIGHTING); // 启用光源

glEnable(GL_LIGHT0); // 启用0号光源

glClearColor( 0.6f, 0.6f, 0.6f, 0.3f);//背景色

前面（一）glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)对应的完整源代码如下:

#pragma comment( lib, “opengl32.lib” )

#pragma comment( lib, “glu32.lib” )

#pragma comment( lib, “glut32.lib”)

#pragma comment( lib, “glew32.lib”)

#pragma comment( lib, “glaux.lib”)

#pragma comment( lib, “vfw32.lib” )

/********************************************************************************************************************************/

#include // Windows的头文件

#include “glew.h” // 包含最新的gl.h,glu.h库

#include // 标准输入/输出库的头文件

#include “glaux.h” // GLaux库的头文件

GLfloat xrot; // X 旋转量

GLfloat yrot; // Y 旋转量

GLfloat zrot; // Z 旋转量

/***********************************新添的代码***********************************************************************************/

GLfloat xspeed; // X 旋转速度

GLfloat yspeed; // Y 旋转速度

BOOL light; // 光源的开/关

BOOL lp; // L键按下了么?

BOOL fp; // F键按下了么?

GLfloat z=-5.0f; // 深入屏幕的距离

GLuint filter; // 滤波类型

GLuint texture[3]; // 3种纹理的储存空间

GLfloat spot1_direction[] = { 0.0f, 0,-1.0f}; // light1的聚光方向,沿相机视线方向

GLfloat angle_Light1 = 30.370f; //聚光源light1的截止角

GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };

//GLfloat mat_diffuse[] = { 0.4, 0.4, 0.4, 1.0 };

GLfloat mat_diffuse[] = { 0.0, 0.0, 0.0, 1.0 };//无散射光

GLfloat mat_emission[] = { 0.0, 0.0, 0.0, 1.0 };//无自发散光

GLfloat mat_specular[] = { 0.4, 0.4, 0.4, 1.0 };

GLfloat mat_shininess[] = { 2.0 };

GLfloat LightPosition[] = { 1.0, 1.0, 1.0, 1.0 };//点光源(位置性光源)

GLfloat LightAmbient[] = { 0.0, 0.0, 0.0, 1.0};//无光源的环境光

GLfloat LightDiffuse[] = {1.0, 1.0, 1.0, 1.0};

GLfloat light_specular[] ={ 0.0, 0.0, 0.0 /*1.0, 1.0, 1.0*/, 1.0};//无镜面光

GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 0.7/*1.0*/};//只有全局环境光

//GLfloat lmodel_ambient[] = { 0.0, 0.0, 0.0, 1.0};

/********************************************************************************************************************************/

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的定义

AUX_RGBImageRec *LoadBMP(CHAR *Filename) // 载入位图图象

{

FILE \*File=NULL;                              // 文件句柄
if (!Filename)                                  //确保文件名已提供
\{
   return NULL;                             //如果没提供，返回NULL
\}
File=fopen(Filename,"r");                       //尝试打开文件
if (File)                                    //文件存在么?
\{
   fclose(File);                             // 关闭句柄
   return auxDIBImageLoadA(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/Crate.bmp"))
\{
   Status=TRUE;                       // 状态设为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设为
\}
glViewport(0,0,width,height);                    // 重置当前的视口
glMatrixMode(GL\_PROJECTION);                     // 选择投影矩阵
glLoadIdentity();                             // 重置投影矩阵
// 设置视口的大小
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
glMatrixMode(GL\_MODELVIEW);                      // 选择模型观察矩阵
glLoadIdentity();                             // 重置模型观察矩阵

}

int InitGL(GLvoid) //此处开始对OpenGL进行所有设置

{

if (!LoadGLTextures())                          //调用纹理载入子例程
\{
   return FALSE;                            //如果未能载入，返回FALSE
\}

/***********************************新添的代码***********************************************************************************/

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\_EMISSION, mat\_emission);
glMaterialfv(GL\_FRONT, GL\_SHININESS, mat\_shininess);
glLightfv(GL\_LIGHT0, GL\_POSITION, LightPosition);//点光源相对视点的位置始终不变,此处是(1,1,1)
glLightfv(GL\_LIGHT0, GL\_AMBIENT, LightAmbient);
glLightfv(GL\_LIGHT0, GL\_DIFFUSE, LightDiffuse);
glLightfv(GL\_LIGHT0, GL\_SPECULAR, light\_specular);
glLightModelfv(GL\_LIGHT\_MODEL\_AMBIENT, lmodel\_ambient);//环境光
//blend
glBlendFunc(GL\_SRC\_ALPHA, GL\_ONE\_MINUS\_SRC\_ALPHA /\*GL\_DST\_ALPHA GL\_ONE\*/);                                // 设置混合函数
glEnable(GL\_LIGHT0);                      // 启用号光源

/********************************************************************************************************************************/

glEnable(GL\_TEXTURE\_2D);                      // 启用纹理映射
glShadeModel(GL\_SMOOTH);                      // 启用阴影平滑
glClearColor( 0.6f, 0.6f, 0.6f, 0.3f);           // 灰色背景
//glClearColor( 0.2f, 0.2f, 0.2f, 0.0f);            //灰色背景
glClearDepth(1.0f);                              // 设置深度缓存
glEnable(GL\_DEPTH\_TEST);                      // 启用深度测试
glDepthFunc(GL\_LEQUAL);                           // 所作深度测试的类型
glHint(GL\_PERSPECTIVE\_CORRECTION\_HINT, GL\_NICEST);   // 告诉系统对透视进行修正
return TRUE;                                 //初始化OK

}

int DrawGLScene(GLvoid) //从这里开始进行所有的绘制

{

glClear(GL\_COLOR\_BUFFER\_BIT | GL\_DEPTH\_BUFFER\_BIT);  // 清除屏幕和深度缓存
glLoadIdentity();                             // 重置当前的模型观察矩阵

/***********************************新添的代码***********************************************************************************/

glTranslatef(0.0f,0.0f,z);                                  // 移入/移出屏幕z 个单位
glEnable(GL\_BLEND);                                           //开启混合
//glDisable(GL\_BLEND);                                            //开启混合
glColor4f( 0.2, 0.2, 0.2, 0.1);
//glColor4f( 1,1,1,0.1);//无光照时glColor4f()有效,alpha=0.1
//glColor4f( 0,0,0,0.3);
glBegin(GL\_QUADS);                                          // 开始绘制四边形
   // 前侧面
   glNormal3f( 0.0f, 0.0f, 1.0f);                          // 法线指向观察者
   glTexCoord2f(0.0f, 0.0f);
       glVertex3f(-1.0f, -1.0f,  1.0f);  
   glTexCoord2f(1.0f, 0.0f);
       glVertex3f( 1.0f, -1.0f,  1.0f);  
   glTexCoord2f(1.0f, 1.0f);
       glVertex3f( 1.0f,  1.0f,  1.0f);  
   glTexCoord2f(0.0f, 1.0f);
       glVertex3f(-1.0f,  1.0f,  1.0f);   /\*\*/  
glEnd();                                                // 四边形绘制结束
xrot+=xspeed;                                           // xrot 增加xspeed 单位
yrot+=yspeed;                                           // yrot 增加yspeed 单位

/********************************************************************************************************************************/

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 - 颜色的位深（/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   设为
WindowRect.right=(long)width;     //将Right  设为要求的宽度
WindowRect.top=(long)0;           //将Top    设为
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,"全屏模式在当前显卡上设置失败！\\n使用窗口模式？","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 变量
fullscreen=FALSE;                      // FALSE为窗口模式
// 创建OpenGL窗口
if (!CreateGLWindow("NeHe's纹理过滤和光照实例",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\['F'\] && !fp)             // F键按下了么?
                 \{
                     fp=TRUE;                    // fp 设为TRUE
                     filter+=1;                  // filter的值加一
                     if (filter>2)              //大于了么?
                     \{
                        filter=0;                // 若是重置为
                     \}
                 \}
                 if (!keys\['F'\])                   // F键放开了么?
                 \{
                     fp=FALSE;                   // 若是fp设为FALSE
                 \}
                 if (keys\[VK\_PRIOR\])               // PageUp按下了?
                 \{
                     z-=0.02f;                   // 若按下，将木箱移向屏幕内部
                 \}
                 if (keys\[VK\_NEXT\])                // PageDown按下了么
                 \{
                     z+=0.02f;                   // 若按下的话，将木箱移向观察者
                 \}
                 if (keys\[VK\_UP\])               // Up方向键按下了么?
                 \{
                     xspeed-=0.01f;                  // 若是,减少xspeed
                 \}
                 if (keys\[VK\_DOWN\])                // Down方向键按下了么?
                 \{
                     xspeed+=0.01f;                  // 若是,增加xspeed
                 \}
                 if (keys\[VK\_RIGHT\])               // Right方向键按下了么?
                 \{  
                     yspeed+=0.01f;                  // 若是,增加yspeed
                 \}
                 if (keys\[VK\_LEFT\])                // Left方向键按下了么?
                 \{
                     yspeed-=0.01f;                  // 若是, 减少yspeed
                 \}

/********************************************************************************************************************************/

          \}
       \}
       if (keys\[VK\_F1\])                  // F1键按下了么?
       \{
          keys\[VK\_F1\]=FALSE;                 // 若是，使对应的Key数组中的值为FALSE
          KillGLWindow();                    // 销毁当前的窗口
          fullscreen=!fullscreen;            // 切换全屏/ 窗口模式

/***********************************新添的代码***********************************************************************************/

          if (!CreateGLWindow("NeHe's纹理过滤和光照实例",640,480,16,fullscreen))
          \{
              return 0;                  //如果窗口未能创建，程序退出
          \}
       \}
   \}
\}
// 关闭程序
KillGLWindow();                               // 销毁窗口
return (msg.wParam);                     //退出程序