opengl纹理,光照,glColor4f(),混合

悠悠 2022-08-13 08:58 183阅读 0赞

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.h>     // Windows的头文件

\#include "glew.h"        // 包含最新的gl.h,glu.h库

\#include <stdio.h>          // 标准输入/输出库的头文件

\#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);                     //退出程序

原文：http://blog.csdn.net/tmljs1988/article/details/6445100

opengl纹理,光照,glColor4f(),混合

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 OpenGL快速入门示例-OpenGL纹理

相关 [OPENGL]纹理，材质，光照

相关 OpenGL函数思考-glColor

相关 opengl纹理,光照,glColor4f(),混合

相关 openGL纹理

相关 OPENGL学习笔记——光照

相关【OpenGL ES】纹理

相关 OpenGL纹理初步认识

相关 OpenGL (二): 纹理绘制

相关 OpenGL学习（4）——纹理（补）