然后保存该文件。下面打开myglwidget.h文件，将类声明补全如下：

再到myglwidget.cpp文件中先包含#include<GL/glu.h>，#include<QKeyEvent>头文件,然后添加类中函数的定义：

构造函数中只需对fullscreen初始化，析构函数暂时并不需要做什么。

glClearColor()函数用来设置清除屏幕时使用的颜色，4个参数分别用来设置红、绿、蓝颜色分量和Alpha值，它们的取值范围都是0.0~1.0，这里4个参数都为0.0，表示纯黑色。然后设置了阴影平滑，这样可以使色彩和光照更加精细。

glViewport()函数用来设置视口的大小。使用glMatrixMode()设置了投影矩阵，投影矩阵用来为场景增加透视，后面使用了glLoadIdentity()重置投影矩阵，这样可以将投影矩阵恢复到初始状态。gluPerspective()用来设置透视投影矩阵，这里设置视角为45°，纵横比为窗口的纵横比，最近的位置为0.1，最远的位置为100，这两个值是场景中所能绘制的深度的临界值。可以想象，离我们眼睛比较近的东西看起来比较大，而比较远的东西看起来就比较小。最后设置并重置了模型视图矩阵。

paintGL()函数包含了所以的绘图代码，任何想在屏幕上显示的东西都将在此段代码中出现。以后每个教程中都会在这个函数增加代码，已达到绘图目的。

最后再向项目中添加main.cpp文件，更改内容如下：

现在就可以运行程序查看效果了！

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glTranslatef(-1.5f, 0.0f, -6.0f);                   //左移1.5单位，并移入屏幕6.0单位
6. glBegin(GL_TRIANGLES);                              //开始绘制三角形
7. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点
8. glVertex3f(-1.0f, -1.0f, 0.0f);                 //左下
9. glVertex3f(1.0f, -1.0f, 0.0f);                  //右下
10. glEnd();                                            //三角形绘制结束
11. glTranslatef(3.0f, 0.0f, 0.0f);                     //右移3.0单位
12. glBegin(GL_QUADS);                                  //开始绘制四边形
13. glVertex3f(-1.0f, 1.0f, 0.0f);                  //左上
14. glVertex3f(1.0f, 1.0f, 0.0f);                   //右上
15. glVertex3f(1.0f, -1.0f, 0.0f);                  //左下
16. glVertex3f(-1.0f, -1.0f, 0.0f);                 //右下
17. glEnd();                                            //四边形绘制结束
18. }

其实与第02课相比，只是增加了4行代码而已。我们利用glColor3f(r, g, b)函数来选择颜色进行着色，该函数三个参数依次是红、绿、蓝三色分量，范围从0.0到1.0之间，类似于之前所讲的清除屏幕背景函数。当我们将颜色设为某种颜色时，接下来的代码绘制出的对象的颜色就都是对应颜色的。

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. GLfloat m_rtri;                                 //控制三角形的角度
20. GLfloat m_rquad;                                //控制四边形的角度
21. };
22. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_rtri = 0.0f;
6. m_rquad = 0.0f;
7. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glTranslatef(-1.5f, 0.0f, -6.0f);                   //左移1.5单位，并移入屏幕6.0单位
6. glRotatef(m_rtri, 0.0f, 1.0f, 0.0f);                //绕y轴旋转三角形
7. glBegin(GL_TRIANGLES);                              //开始绘制三角形
8. glColor3f(1.0f, 0.0f, 0.0f);                    //设置当前色为红色
9. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点
10. glColor3f(0.0f, 1.0f, 0.0f);                    //设置当前色为绿色
11. glVertex3f(-1.0f, -1.0f, 0.0f);                 //左下
12. glColor3f(0.0f, 0.0f, 1.0f);                    //设置当前色为蓝色
13. glVertex3f(1.0f, -1.0f, 0.0f);                  //右下
14. glEnd();                                            //三角形绘制结束
15. glLoadIdentity();                                   //重置模型观察矩阵
16. glTranslatef(1.5f, 0.0f, -6.0f);                    //右移1.5单位，并移入屏幕6.0单位
17. glRotatef(m_rquad, 1.0f, 0.0f, 0.0f);               //绕x轴旋转四边形
18. glColor3f(0.5f, 0.5f, 1.0f);                        //一次性将当前色设置为蓝色
19. glBegin(GL_QUADS);                                  //开始绘制四边形
20. glVertex3f(-1.0f, 1.0f, 0.0f);                  //左上
21. glVertex3f(1.0f, 1.0f, 0.0f);                   //右上
22. glVertex3f(1.0f, -1.0f, 0.0f);                  //左下
23. glVertex3f(-1.0f, -1.0f, 0.0f);                 //右下
24. glEnd();                                            //四边形绘制结束
25. m_rtri += 0.5f;                                     //增加三角形的旋转变量
26. m_rquad -= 0.5f;                                    //减少四边形的旋转变量
27. }

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_rtri = 0.0f;
6. m_rquad = 0.0f;
7. QTimer *timer = new QTimer(this);                   //创建一个定时器
8. //将定时器的计时信号与updateGL()绑定
9. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
10. timer->start(10);                                   //以10ms为一个计时周期
11. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glTranslatef(-1.5f, 0.0f, -6.0f);                   //左移1.5单位，并移入屏幕6.0单位
6. glRotatef(m_rtri, 0.0f, 1.0f, 0.0f);                //绕y轴旋转三角形
7. glBegin(GL_TRIANGLES);                              //开始绘制金字塔
8. glColor3f(1.0f, 0.0f, 0.0f);                    //红色
9. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点(前侧面)
10. glColor3f(0.0f, 1.0f, 0.0f);                    //绿色
11. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左下(前侧面)
12. glColor3f(0.0f, 0.0f, 1.0f);                    //蓝色
13. glVertex3f(1.0f, -1.0f, 1.0f);                  //右下(前侧面)
14. glColor3f(1.0f, 0.0f, 0.0f);                    //红色
15. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点(右侧面)
16. glColor3f(0.0f, 0.0f, 1.0f);                    //蓝色
17. glVertex3f(1.0f, -1.0f, 1.0f);                  //左下(右侧面)
18. glColor3f(0.0f, 1.0f, 0.0f);                    //绿色
19. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(右侧面)
20. glColor3f(1.0f, 0.0f, 0.0f);                    //红色
21. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点(后侧面)
22. glColor3f(0.0f, 1.0f, 0.0f);                    //绿色
23. glVertex3f(1.0f, -1.0f, -1.0f);                 //左下(后侧面)
24. glColor3f(0.0f, 0.0f, 1.0f);                    //蓝色
25. glVertex3f(-1.0f, -1.0f, -1.0f);                //右下(后侧面)
26. glColor3f(1.0f, 0.0f, 0.0f);                    //红色
27. glVertex3f(0.0f, 1.0f, 0.0f);                   //上顶点(左侧面)
28. glColor3f(0.0f, 0.0f, 1.0f);                    //蓝色
29. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(左侧面)
30. glColor3f(0.0f, 1.0f, 0.0f);                    //绿色
31. glVertex3f(-1.0f, -1.0f, 1.0f);                 //右下(左侧面)
32. glEnd();                                            //金字塔绘制结束
33. glLoadIdentity();                                   //重置模型观察矩阵
34. glTranslatef(1.5f, 0.0f, -6.0f);                    //右移1.5单位，并移入屏幕6.0单位
35. glRotatef(m_rquad, 1.0f, 0.0f, 0.0f);               //绕x轴旋转四边形
36. glBegin(GL_QUADS);                                  //开始绘制立方体
37. glColor3f(0.0f, 1.0f, 0.0f);                    //绿色
38. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(顶面)
39. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(顶面)
40. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左下(顶面)
41. glVertex3f(1.0f, 1.0f, 1.0f);                   //右下(顶面)
42. glColor3f(1.0f, 0.5f, 0.0f);                    //橙色
43. glVertex3f(1.0f, -1.0f, 1.0f);                  //右上(底面)
44. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左上(底面)
45. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(底面)
46. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(底面)
47. glColor3f(1.0f, 0.0f, 0.0f);                    //红色
48. glVertex3f(1.0f, 1.0f, 1.0f);                   //右上(前面)
49. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左上(前面)
50. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左下(前面)
51. glVertex3f(1.0f, -1.0f, 1.0f);                  //右下(前面)
52. glColor3f(1.0f, 1.0f, 0.0f);                    //黄色
53. glVertex3f(1.0f, -1.0f, -1.0f);                 //右上(后面)
54. glVertex3f(-1.0f, -1.0f, -1.0f);                //左上(后面)
55. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左下(后面)
56. glVertex3f(1.0f, 1.0f, -1.0f);                  //右下(后面)
57. glColor3f(0.0f, 0.0f, 1.0f);                    //蓝色
58. glVertex3f(-1.0f, 1.0f, 1.0f);                  //右上(左面)
59. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(左面)
60. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(左面)
61. glVertex3f(-1.0f, -1.0f, 1.0f);                 //右下(左面)
62. glColor3f(1.0f, 0.0f, 1.0f);                    //紫色
63. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(右面)
64. glVertex3f(1.0f, 1.0f, 1.0f);                   //左上(右面)
65. glVertex3f(1.0f, -1.0f, 1.0f);                  //左下(右面)
66. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(右面)
67. glEnd();                                            //立方体绘制结束
68. m_rtri += 0.5f;                                     //增加金字体的旋转变量
69. m_rquad -= 0.5f;                                    //减少立方体的旋转变量
70. }

增加的前三个变量用来使立方体绕x、y、z轴旋转，m_FileName用于储存图片的路径及文件名，m_Texture为一个纹理分配存储空间。如果需要不止一个纹理，可以创建一个数组来储存不同的纹理。

然后这次我们需要对initializeGL()函数作一定的修改了，具体代码如下：

我们增加了两行代码，首先调用了Qt提供的bindTexture()函数将图片载入并转换成纹理，然后启用2D纹理映射。如果忘记启用的话，我们的对象看起来永远都是纯白色的，这明显与我们的预期大相径庭。

这次我们需要让对象依次绕x、y、z轴旋转，旋转多少依赖于变量m_xRot、m_yRot、m_zRot的值。下面我们调用glBindTexture()函数来选择要绑定的纹理，第2个参数表示所要绑定的纹理。当想改变纹理时，应该绑定新的纹理，要注意的是，我们不能在glBegin()和glEnd()直接绑定纹理，那样绑定的纹理时无效的。

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. QString m_FileName;                             //图片的路径及文件名
20. GLuint m_Texture;                               //储存一个纹理
21. bool m_Light;                                   //光源的开/关
22. GLfloat m_xRot;                                 //x旋转角度
23. GLfloat m_yRot;                                 //y旋转角度
24. GLfloat m_xSpeed;                               //x旋转速度
25. GLfloat m_ySpeed;                               //y旋转速度
26. GLfloat m_Deep;                                 //深入屏幕的距离
27. };
28. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FileName = "D:/QtOpenGL/QtImage/Crate.bmp";        //应根据实际存放图片的路径进行修改
6. m_Light = false;
7. m_xRot = 0.0f;
8. m_yRot = 0.0f;
9. m_xSpeed = 0.0f;
10. m_ySpeed = 0.0f;
11. m_Deep = -5.0f;
12. QTimer *timer = new QTimer(this);                   //创建一个定时器
13. //将定时器的计时信号与updateGL()绑定
14. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
15. timer->start(10);                                   //以10ms为一个计时周期
16. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glEnable(GL_DEPTH_TEST);                            //启用深度测试
9. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
10. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
11. GLfloat LightAmbient[] = {0.5f, 0.5f, 0.5f, 1.0f};  //环境光参数
12. GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};  //漫散光参数
13. GLfloat LightPosition[] = {0.0f, 0.0f, 2.0f, 1.0f}; //光源位置
14. glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);     //设置环境光
15. glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);     //设置漫射光
16. glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);   //设置光源位置
17. glEnable(GL_LIGHT1);                                //启动一号光源
18. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置模型观察矩阵
5. glTranslatef(0.0f, 0.0f, m_Deep);                   //移入屏幕
6. glRotatef(m_xRot, 1.0f, 0.0f, 0.0f);                //绕x轴旋转
7. glRotatef(m_yRot, 0.0f, 1.0f, 0.0f);                //绕y轴旋转
8. glBindTexture(GL_TEXTURE_2D, m_Texture);            //选择纹理
9. glBegin(GL_QUADS);                                  //开始绘制立方体
10. glNormal3f(0.0f, 1.0f, 0.0f);
11. glTexCoord2f(1.0f, 1.0f);
12. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(顶面)
13. glTexCoord2f(0.0f, 1.0f);
14. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(顶面)
15. glTexCoord2f(0.0f, 0.0f);
16. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左下(顶面)
17. glTexCoord2f(1.0f, 0.0f);
18. glVertex3f(1.0f, 1.0f, 1.0f);                   //右下(顶面)
19. glNormal3f(0.0f, -1.0f, 0.0f);
20. glTexCoord2f(0.0f, 0.0f);
21. glVertex3f(1.0f, -1.0f, 1.0f);                  //右上(底面)
22. glTexCoord2f(1.0f, 0.0f);
23. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左上(底面)
24. glTexCoord2f(1.0f, 1.0f);
25. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(底面)
26. glTexCoord2f(0.0f, 1.0f);
27. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(底面)
28. glNormal3f(0.0f, 0.0f, 1.0f);
29. glTexCoord2f(1.0f, 1.0f);
30. glVertex3f(1.0f, 1.0f, 1.0f);                   //右上(前面)
31. glTexCoord2f(0.0f, 1.0f);
32. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左上(前面)
33. glTexCoord2f(0.0f, 0.0f);
34. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左下(前面)
35. glTexCoord2f(1.0f, 0.0f);
36. glVertex3f(1.0f, -1.0f, 1.0f);                  //右下(前面)
37. glNormal3f(0.0f, 0.0f, -1.0f);
38. glTexCoord2f(0.0f, 0.0f);
39. glVertex3f(1.0f, -1.0f, -1.0f);                 //右上(后面)
40. glTexCoord2f(1.0f, 0.0f);
41. glVertex3f(-1.0f, -1.0f, -1.0f);                //左上(后面)
42. glTexCoord2f(1.0f, 1.0f);
43. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左下(后面)
44. glTexCoord2f(0.0f, 1.0f);
45. glVertex3f(1.0f, 1.0f, -1.0f);                  //右下(后面)
46. glNormal3f(-1.0f, 0.0f, 0.0f);
47. glTexCoord2f(1.0f, 1.0f);
48. glVertex3f(-1.0f, 1.0f, 1.0f);                  //右上(左面)
49. glTexCoord2f(0.0f, 1.0f);
50. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(左面)
51. glTexCoord2f(0.0f, 0.0f);
52. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(左面)
53. glTexCoord2f(1.0f, 0.0f);
54. glVertex3f(-1.0f, -1.0f, 1.0f);                 //右下(左面)
55. glNormal3f(1.0f, 0.0f, 0.0f);
56. glTexCoord2f(1.0f, 1.0f);
57. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(右面)
58. glTexCoord2f(0.0f, 1.0f);
59. glVertex3f(1.0f, 1.0f, 1.0f);                   //左上(右面)
60. glTexCoord2f(0.0f, 0.0f);
61. glVertex3f(1.0f, -1.0f, 1.0f);                  //左下(右面)
62. glTexCoord2f(1.0f, 0.0f);
63. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(右面)
64. glEnd();                                            //立方体绘制结束
65. m_xRot += m_xSpeed;                                 //x轴旋转
66. m_yRot += m_ySpeed;                                 //y轴旋转
67. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. break;
16. case Qt::Key_Escape:                                //ESC为退出键
17. close();
18. break;
19. case Qt::Key_L:                                     //L为开启关闭光源的切换键
20. m_Light = !m_Light;
21. if (m_Light)
22. {
23. glEnable(GL_LIGHTING);                      //开启光源
24. }
25. else
26. {
27. glDisable(GL_LIGHTING);                     //关闭光源
28. }
29. break;
30. case Qt::Key_PageUp:                                //PageUp按下使木箱移向屏幕内部
31. m_Deep -= 0.1f;
32. break;
33. case Qt::Key_PageDown:                              //PageDown按下使木箱移向观察者
34. m_Deep += 0.1f;
35. break;
36. case Qt::Key_Up:                                    //Up按下减少m_xSpeed
37. m_xSpeed -= 0.1f;
38. break;
39. case Qt::Key_Down:                                  //Down按下增加m_xSpeed
40. m_xSpeed += 0.1f;
41. break;
42. case Qt::Key_Right:                                 //Right按下减少m_ySpeed
43. m_ySpeed -= 0.1f;
44. break;
45. case Qt::Key_Left:                                  //Left按下增加m_ySpeed
46. m_ySpeed += 0.1f;
47. break;
48. }
49. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. QString m_FileName;                             //图片的路径及文件名
20. GLuint m_Texture;                               //储存一个纹理
21. bool m_Light;                                   //光源的开/关
22. bool m_Blend;                                   //是否混合
23. GLfloat m_xRot;                                 //x旋转角度
24. GLfloat m_yRot;                                 //y旋转角度
25. GLfloat m_xSpeed;                               //x旋转速度
26. GLfloat m_ySpeed;                               //y旋转速度
27. GLfloat m_Deep;                                 //深入屏幕的距离
28. };
29. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FileName = "D:/QtOpenGL/QtImage/Glass.bmp";        //应根据实际存放图片的路径进行修改
6. m_Light = false;
7. m_Blend = false;
8. m_xRot = 0.0f;
9. m_yRot = 0.0f;
10. m_xSpeed = 0.0f;
11. m_ySpeed = 0.0f;
12. m_Deep = -5.0f;
13. QTimer *timer = new QTimer(this);                   //创建一个定时器
14. //将定时器的计时信号与updateGL()绑定
15. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
16. timer->start(10);                                   //以10ms为一个计时周期
17. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glEnable(GL_DEPTH_TEST);                            //启用深度测试
9. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
10. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
11. //下面是光源部分
12. GLfloat LightAmbient[] = {0.5f, 0.5f, 0.5f, 1.0f};  //环境光参数
13. GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};  //漫散光参数
14. GLfloat LightPosition[] = {0.0f, 0.0f, 2.0f, 1.0f}; //光源位置
15. glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);     //设置环境光
16. glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);     //设置漫射光
17. glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);   //设置光源位置
18. glEnable(GL_LIGHT1);                                //启动一号光源
19. //下面是混合部分
20. glColor4f(1.0f, 1.0f, 1.0f, 0.5f);                  //全亮度，50%Alpha混合
21. glBlendFunc(GL_SRC_ALPHA, GL_ONE);                  //基于源像素alpah通道值得半透明混合函数
22. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. break;
16. case Qt::Key_Escape:                                //ESC为退出键
17. close();
18. break;
19. case Qt::Key_B:                                     //B为开始关闭混合而对切换键
20. m_Blend = !m_Blend;
21. if (m_Blend)
22. {
23. glEnable(GL_BLEND);                         //开启混合
24. glDisable(GL_DEPTH_TEST);                   //关闭深度测试
25. }
26. else
27. {
28. glDisable(GL_BLEND);                        //关闭混合
29. glEnable(GL_DEPTH_TEST);                    //打开深度测试
30. }
31. break;
32. case Qt::Key_L:                                     //L为开启关闭光源的切换键
33. m_Light = !m_Light;
34. if (m_Light)
35. {
36. glEnable(GL_LIGHTING);                      //开启光源
37. }
38. else
39. {
40. glDisable(GL_LIGHTING);                     //关闭光源
41. }
42. break;
43. case Qt::Key_PageUp:                                //PageUp按下使木箱移向屏幕内部
44. m_Deep -= 0.1f;
45. break;
46. case Qt::Key_PageDown:                              //PageDown按下使木箱移向观察者
47. m_Deep += 0.1f;
48. break;
49. case Qt::Key_Up:                                    //Up按下减少m_xSpeed
50. m_xSpeed -= 0.1f;
51. break;
52. case Qt::Key_Down:                                  //Down按下增加m_xSpeed
53. m_xSpeed += 0.1f;
54. break;
55. case Qt::Key_Right:                                 //Right按下减少m_ySpeed
56. m_ySpeed -= 0.1f;
57. break;
58. case Qt::Key_Left:                                  //Left按下增加m_ySpeed
59. m_ySpeed += 0.1f;
60. break;
61. }
62. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. QString m_FileName;                             //图片的路径及文件名
20. GLuint m_Texture;                               //储存一个纹理
21. bool m_Twinkle;                                 //星星是否闪烁
22. static const int num = 50;                      //星星的数目
23. struct star{                                    //为星星创建的结构体
24. int r, g, b;                                //星星的颜色
25. GLfloat dist;                               //星星距离中心的距离
26. GLfloat angle;                              //当前星星所处的角度
27. } m_stars[num];
28. GLfloat m_Deep;                                 //星星离观察者的距离
29. GLfloat m_Tilt;                                 //星星的倾角
30. GLfloat m_Spin;                                 //星星的自转
31. };
32. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FileName = "D:/QtOpenGL/QtImage/Star.bmp";        //应根据实际存放图片的路径进行修改
6. m_Twinkle = false;                                  //默认初始状态为不闪烁
7. for (int i=0; i<num; i++)                           //循环初始化所有的星星
8. {
9. //随机获得星星颜色
10. m_stars[i].r = rand() % 256;
11. m_stars[i].g = rand() % 256;
12. m_stars[i].b = rand() % 256;
13. m_stars[i].dist = ((float)i / num) * 5.0f;      //计算星星离中心的距离，最大半径为5.0
14. m_stars[i].angle = 0.0f;                        //所以星星都从0度开始旋转
15. }
16. m_Deep = -15.0f;                                    //深入屏幕15.0单位
17. m_Tilt = 90.0f;                                     //初始倾角为90度(面对观察者)
18. m_Spin = 0.0f;                                      //从0度开始自转
19. QTimer *timer = new QTimer(this);                   //创建一个定时器
20. //将定时器的计时信号与updateGL()绑定
21. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
22. timer->start(10);                                   //以10ms为一个计时周期
23. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));
4. glEnable(GL_TEXTURE_2D);
5. glClearColor(0.0, 0.0, 0.0, 0.0);                   //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
9. glBlendFunc(GL_SRC_ALPHA, GL_ONE);                  //设置混色函数取得半透明效果
10. glEnable(GL_BLEND);                                 //开启混合(混色)
11. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glBindTexture(GL_TEXTURE_2D, m_Texture);            //选择纹理
5. for (int i=0; i<num; i++)
6. {
7. glLoadIdentity();                               //绘制每颗星星之前，重置模型观察矩阵
8. glTranslatef(0.0f, 0.0f, m_Deep);               //深入屏幕里面
9. glRotatef(m_Tilt, 1.0f, 0.0f, 0.0f);            //倾斜视角
10. glRotatef(m_stars[i].angle, 0.0f, 1.0f, 0.0f);  //旋转至当前所画星星的角度
11. glTranslatef(m_stars[i].dist, 0.0f, 0.0f);      //沿x轴正向移动
12. glRotatef(-m_stars[i].angle, 0.0f, 1.0f, 0.0f); //取消当前星星的角度
13. glRotatef(-m_Tilt, 1.0f, 0.0f, 0.0f);           //取消视角倾斜
14. if (m_Twinkle)                                  //启动闪烁效果
15. {
16. //使用byte型数据值指定一个颜色
17. glColor4ub(m_stars[num-i-1].r, m_stars[num-i-1].g, m_stars[num-i-1].b, 255);
18. glBegin(GL_QUADS);                          //开始绘制纹理映射过的四边形
19. glTexCoord2f(0.0f, 0.0f);
20. glVertex3f(-1.0f, -1.0f, 0.0f);
21. glTexCoord2f(1.0f, 0.0f);
22. glVertex3f(1.0f, -1.0f, 0.0f);
23. glTexCoord2f(1.0f, 1.0f);
24. glVertex3f(1.0f, 1.0f, 0.0f);
25. glTexCoord2f(0.0f, 1.0f);
26. glVertex3f(-1.0f, 1.0f, 0.0f);
27. glEnd();                                    //四边形绘制结束
28. }
29. glRotatef(m_Spin, 0.0f, 0.0f, 1.0f);            //绕z轴旋转星星
30. //使用byte型数据值指定一个颜色
31. glColor4ub(m_stars[i].r, m_stars[i].g, m_stars[i].b, 255);
32. glBegin(GL_QUADS);                          //开始绘制纹理映射过的四边形
33. glTexCoord2f(0.0f, 0.0f);
34. glVertex3f(-1.0f, -1.0f, 0.0f);
35. glTexCoord2f(1.0f, 0.0f);
36. glVertex3f(1.0f, -1.0f, 0.0f);
37. glTexCoord2f(1.0f, 1.0f);
38. glVertex3f(1.0f, 1.0f, 0.0f);
39. glTexCoord2f(0.0f, 1.0f);
40. glVertex3f(-1.0f, 1.0f, 0.0f);
41. glEnd();                                    //四边形绘制结束
42. m_Spin += 0.01f;                            //星星的自转
43. m_stars[i].angle += (float)i / num;         //改变星星的公转角度
44. m_stars[i].dist -= 0.01f;                   //改变星星离中心的距离
45. if (m_stars[i].dist < 0.0f)                 //星星到达中心了么
46. {
47. m_stars[i].dist += 5.0f;                //往外移5.0单位
48. m_stars[i].r = rand() % 256;
49. m_stars[i].g = rand() % 256;
50. m_stars[i].b = rand() % 256;
51. }
52. }
53. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. updateGL();
16. break;
17. case Qt::Key_Escape:                            //ESC为退出键
18. close();
19. break;
20. case Qt::Key_T:                                 //T为星星开启关闭闪烁的切换键
21. m_Twinkle = !m_Twinkle;
22. break;
23. case Qt::Key_Up:                                //Up按下屏幕向上倾斜
24. m_Tilt -= 0.5f;
25. break;
26. case Qt::Key_Down:                              //Down按下屏幕向下倾斜
27. m_Tilt += 0.5f;
28. break;
29. case Qt::Key_PageUp:                            //PageUp按下缩小
30. m_Deep -= 0.1f;
31. break;
32. case Qt::Key_PageDown:                          //PageDown按下放大
33. m_Deep += 0.1f;
34. break;
35. }
36. }

可以看到我们定义了3个结构体，依次表示顶点，三角形和区段。一个区段包含一系列的多边形（三角形），三角形本质上是由三个以上顶点组合的图形，顶点就是我们最基本的分类单位了。顶点包含了OpenGL真正感兴趣的数据，我们用3D空间中的坐标值(x, y, z)以及它们的纹理坐标(u, v)来定义三角形的每个顶点。这次教程中，我们只加载了一个区段的数据，故只需一个m_Sector数据就够了（当然有兴趣的可以自己设计区段数据，多加载几个看看）。

我们重点解释中间对于m_Sector的初始化，我们先将文件打开，再利用Qt的文本流一行一行的读取（为何一行一行读，大家看下存放数据的文本文件World.txt就知道了）并保证读入的数据是有效的。每当成功读入三行数据时，说明构成了一个三角形，就创建一个三角形来储存这些数据，并在最后把三角形放入m_Sector中，当然要给m_Sector的numtriangles加上一，说明多了一个三角形。最后录完数据后，关上文件。或者你会想如果有效数据行数不是3的倍数怎么办，这个问题其实已经不是我们的问题了，而且提供的数据文本存在问题，因此不必考虑。接着的数据初始化不作解释了。

这个实现很简单。当左右方向键按下后，旋转变量m_yRot相应的增加或减少。当前后方向键按下时，我们使用sin()和cos()函数计算具体在x和z轴方向上的位移量，使得游戏者能准确的移动。

就正如我们之前步骤2和3所说，我们以相反的方式来平移和旋转场景，使得看上去是视角在平移和旋转，然后绑定纹理并绘制出整个场景就完成了！

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. GLfloat m_xRot;                                 //绕x轴旋转的角度
20. GLfloat m_yRot;                                 //绕y轴旋转的角度
21. GLfloat m_zRot;                                 //绕z轴旋转的角度
22. QString m_FileName;                             //图片的路径及文件名
23. GLuint m_Texture;                               //储存一个纹理
24. float m_Points[45][45][3];                      //储存网格顶点的数组
25. int m_WiggleCount;                              //用于控制旗帜波浪运动动画
26. };
27. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_xRot = 0.0f;
6. m_yRot = 0.0f;
7. m_zRot = 0.0f;
8. m_FileName = "D:/QtOpenGL/QtImage/Tim.bmp";         //应根据实际存放图片的路径进行修改
9. for (int x=0; x<45; x++)                            //初始化数组产生波浪效果(静止)
10. {
11. for (int y=0; y<45; y++)
12. {
13. m_Points[x][y][0] = float((x / 5.0f) - 4.5f);
14. m_Points[x][y][1] = float((y / 5.0f) - 4.5f);
15. m_Points[x][y][2] = float(sin((((x/5.0f)*40.0f)/360.0f)*3.141592654*2.0f));
16. }
17. }
18. m_WiggleCount = 0;
19. QTimer *timer = new QTimer(this);                   //创建一个定时器
20. //将定时器的计时信号与updateGL()绑定
21. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
22. timer->start(10);                                   //以10ms为一个计时周期
23. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.0, 0.0, 0.0, 0.0);                   //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glEnable(GL_DEPTH_TEST);                            //启用深度测试
9. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
10. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
11. glPolygonMode(GL_BACK, GL_FILL);                    //后表面完全填充
12. glPolygonMode(GL_FRONT, GL_LINE);                   //前表面使用线条绘制
13. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glTranslatef(0.0f, 0.0f, -15.0f);                   //移入屏幕15.0单位
6. glRotatef(m_xRot, 1.0f, 0.0f, 0.0f);                //绕x旋转
7. glRotatef(m_yRot, 0.0f, 1.0f, 0.0f);                //绕y旋转
8. glRotatef(m_zRot, 0.0f, 0.0f, 1.0f);                //绕z旋转
9. glBindTexture(GL_TEXTURE_2D, m_Texture);            //旋转纹理
10. float flag_x1, flag_y1, flag_x2, flag_y2;           //用来将纹理分割成小的四边形方便纹理映射
11. glBegin(GL_QUADS);
12. for (int x=0; x<44; x++)
13. {
14. for (int y=0; y<44; y++)
15. {
16. //分割纹理
17. flag_x1 = float(x) / 44.0f;
18. flag_y1 = float(y) / 44.0f;
19. flag_x2 = float(x+1) / 44.0f;
20. flag_y2 = float(y+1) / 44.0f;
21. //绘制一个小的四边形
22. glTexCoord2f(flag_x1, flag_y1);
23. glVertex3f(m_Points[x][y][0], m_Points[x][y][1], m_Points[x][y][2]);
24. glTexCoord2f(flag_x1, flag_y2);
25. glVertex3f(m_Points[x][y+1][0], m_Points[x][y+1][1], m_Points[x][y+1][2]);
26. glTexCoord2f(flag_x2, flag_y2);
27. glVertex3f(m_Points[x+1][y+1][0], m_Points[x+1][y+1][1], m_Points[x+1][y+1][2]);
28. glTexCoord2f(flag_x2, flag_y1);
29. glVertex3f(m_Points[x+1][y][0], m_Points[x+1][y][1], m_Points[x+1][y][2]);
30. }
31. }
32. glEnd();
33. if (m_WiggleCount == 3)                             //用来变换波浪形状(每2帧一次)产生波浪动画
34. {
35. //利用循环使波浪值集体左移，最左侧波浪值到了最右侧
36. for (int y=0; y<45; y++)
37. {
38. float temp = m_Points[0][y][2];
39. for (int x=0; x<44; x++)
40. {
41. m_Points[x][y][2] = m_Points[x+1][y][2];
42. }
43. m_Points[44][y][2] = temp;
44. }
45. m_WiggleCount = 0;                              //计数器清零
46. }
47. m_WiggleCount++;                                    //计数器加一
48. m_xRot += 0.3f;
49. m_yRot += 0.2f;
50. m_zRot += 0.4f;
51. }

我们新增了两个用于显示列表的变量m_Box、m_Top，这两个变量是用于储存指向显示列表的指针。另外我们多了一个buildLists()函数，这个函数是用于初始化两个显示列表的（注意我去掉了变量m_zRot，但其实影响不大）。

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. void buildFont();                               //创建字体
19. void killFont();                                //删除显示列表
20. void glPrint(const char *fmt, ...);             //输出字符串
21. private:
22. bool fullscreen;                                //是否全屏显示
23. HDC m_HDC;                                      //储存当前设备的指针
24. int m_FontSize;                                 //控制字体的大小
25. GLuint m_Base;                                  //储存绘制字体的显示列表的开始位置
26. GLfloat m_Cnt1;                                 //字体移动计数器1
27. GLfloat m_Cnt2;                                 //字体移动计数器2
28. };
29. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FontSize = -18;
6. m_Cnt1 = 0.0f;
7. m_Cnt2 = 0.0f;
8. HWND hWND = (HWND)winId();                          //获取当前窗口句柄
9. m_HDC = GetDC(hWND);                                //通过窗口句柄获得HDC
10. QTimer *timer = new QTimer(this);                   //创建一个定时器
11. //将定时器的计时信号与updateGL()绑定
12. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
13. timer->start(10);                                   //以10ms为一个计时周期
14. }

1. MyGLWidget::~MyGLWidget()
2. {
3. killFont();                                         //删除显示列表
4. }

1. void MyGLWidget::buildFont()                            //创建位图字体
2. {
3. HFONT font;                                         //字体句柄
4. m_Base = glGenLists(96);                            //创建96个显示列表
5. font = CreateFont(m_FontSize,                       //字体高度
6. 0,                                //字体宽度
7. 0,                                //字体的旋转角度
8. 0,                                //字体底线的旋转角度
9. FW_BOLD,                          //字体的重量
10. FALSE,                            //是否斜体
11. FALSE,                            //是否使用下划线
12. FALSE,                            //是否使用删除线
13. ANSI_CHARSET,                     //设置字符集
14. OUT_TT_PRECIS,                    //输出精度
15. CLIP_DEFAULT_PRECIS,              //剪裁精度
16. ANTIALIASED_QUALITY,              //输出质量
17. FF_DONTCARE | DEFAULT_PITCH,      //Family and Pitch的设置
18. LPCWSTR("Courier New"));          //字体名称(电脑中已装的)
19. wglUseFontBitmaps(m_HDC, 32, 96, m_Base);           //创建96个显示列表，绘制ASCII码为32-128的字符
20. SelectObject(m_HDC, font);                          //选择字体
21. }

1. void MyGLWidget::killFont()                             //删除显示列表
2. {
3. glDeleteLists(m_Base, 96);                          //删除96个显示列表
4. }

1. void MyGLWidget::glPrint(const char *fmt, ...)          //自定义输出文字函数
2. {
3. char text[256];                                     //保存字符串
4. va_list ap;                                         //指向一个变量列表的指针
5. if (fmt == NULL)                                    //如果无输入则返回
6. {
7. return;
8. }
9. va_start(ap, fmt);                                  //分析可变参数
10. vsprintf(text, fmt, ap);                        //把参数值写入字符串
11. va_end(ap);                                         //结束分析
12. glPushAttrib(GL_LIST_BIT);                          //把显示列表属性压入属性堆栈
13. glListBase(m_Base - 32);                            //设置显示列表的基础值
14. glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);  //调用显示列表绘制字符串
15. glPopAttrib();                                      //弹出属性堆栈
16. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. glClearColor(0.0, 0.0, 0.0, 0.0);                   //黑色背景
4. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
5. glClearDepth(1.0);                                  //设置深度缓存
6. glEnable(GL_DEPTH_TEST);                            //启用深度测试
7. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
8. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
9. buildFont();                                        //创建字体
10. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glTranslatef(0.0f, 0.0f, -10.0f);                   //移入屏幕10.0单位
6. //根据字体位置设置颜色
7. glColor3f(1.0f*float(cos(m_Cnt1)), 1.0f*float(sin(m_Cnt2)),
8. 1.0f-0.5f*float(cos(m_Cnt1+m_Cnt2)));
9. //设置光栅化位置，即字体位置
10. glRasterPos2f(-4.5f+0.5f*float(cos(m_Cnt1)), 1.92f*float(sin(m_Cnt2)));
11. //输出文字到屏幕上
12. glPrint("Active OpenGL Text With NeHe - %7.2f", m_Cnt1);
13. m_Cnt1 += 0.051f;                                   //增加两个计数器的值
14. m_Cnt2 += 0.005f;
15. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. updateGL();
16. break;
17. case Qt::Key_Escape:                                //ESC为退出键
18. close();
19. break;
20. case Qt::Key_PageUp:                                //PageUp按下字体缩小
21. m_FontSize -= 1;
22. if (m_FontSize < -75)
23. {
24. m_FontSize = -75;
25. }
26. buildFont();
27. break;
28. case Qt::Key_PageDown:                              //PageDown按下字体放大
29. m_FontSize += 1;
30. if (m_FontSize > -5)
31. {
32. m_FontSize = -5;
33. }
34. buildFont();
35. break;
36. }
37. }

由于我们没有准备让轮廓字体移动，所以删掉两个计数器。接着增加m_Deep来控制移入屏幕的距离，其实就是来控制字体的放大缩小的。然后再增加m_Rot来控制字体的旋转。最后增加了GLYPHMETRICSFLOAT变量数组m_Gmf[256]用来保存256个轮廓字体显示列表中对应的每一个列表的位置和方向信息，我们通过m_Gmf[num]来选择字母。要注意的是，每个字符的宽度可以不相同，使用GLYPHMETRICS会大大简化我们的工作。

继续，我们需要对buildFont()、killFont()、glPrint()三个函数作一定的修改，具体代码如下：

首先是buildFont()函数。首先创建字体的方法与上一课基本一致，只是把m_FontSize换成了-18。接着，将wglUseFontBitmaps()函数替换成wglUseFontOutlines()函数，这个函数包含了8个参数前4个参数大家自己看注释，第5个参数为光滑度系数，这个值越小，字体看起来会越光滑（其实看不出明显差别）。第6个参数简单点说指的是字体的厚度，有厚度的字体才有立体感嘛，如果这个值为0.0就变成2D字体了。第7个参数告诉OpenGL用多边形来生成字符，使每个顶点都会具有独立的法线，这样加上光源后会有不错的效果（光源效果我们的代码中没有，大家可以自己加加看）。最后一个参数告诉OpenGL把创建的显示列表的度量数据（高度、宽度等）放在数组m_Gmf[]中。

最后，修改键盘控制的代码，就是按PageUp和PageDown可以放大缩小字体，具体代码如下：

现在就可以运行程序查看效果了！

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. void buildFont();                               //创建字体
19. void killFont();                                //删除显示列表
20. void glPrint(const char *fmt, ...);             //输出字符串
21. private:
22. bool fullscreen;                                //是否全屏显示
23. HDC m_HDC;                                      //储存当前设备的指针
24. GLYPHMETRICSFLOAT m_Gmf[256];                   //记录256个字符的信息
25. GLfloat m_Deep;                                 //移入屏幕的距离
26. GLuint m_Base;                                  //储存绘制字体的显示列表的开始位置
27. GLfloat m_Rot;                                  //用于旋转字体
28. QString m_FileName;                             //图片的路径及文件名
29. GLuint m_Texture;                               //储存一个纹理
30. };
31. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_Deep = -3.0f;
6. m_Rot = 0.0f;
7. m_FileName = "D:/QtOpenGL/QtImage/Lights.bmp";        //应根据实际存放图片的路径进行修改
8. HWND hWND = (HWND)winId();                          //获取当前窗口句柄
9. m_HDC = GetDC(hWND);                                //通过窗口句柄获得HDC
10. QTimer *timer = new QTimer(this);                   //创建一个定时器
11. //将定时器的计时信号与updateGL()绑定
12. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
13. timer->start(10);                                   //以10ms为一个计时周期
14. }

1. void MyGLWidget::buildFont()                            //创建位图字体
2. {
3. HFONT font;                                         //字体句柄
4. m_Base = glGenLists(256);                           //创建256个显示列表
5. font = CreateFont(-18,                              //字体高度
6. 0,                                //字体宽度
7. 0,                                //字体的旋转角度
8. 0,                                //字体底线的旋转角度
9. FW_BOLD,                          //字体的重量
10. FALSE,                            //是否斜体
11. FALSE,                            //是否使用下划线
12. FALSE,                            //是否使用删除线
13. SYMBOL_CHARSET,                   //设置字符集
14. OUT_TT_PRECIS,                    //输出精度
15. CLIP_DEFAULT_PRECIS,              //剪裁精度
16. ANTIALIASED_QUALITY,              //输出质量
17. FF_DONTCARE | DEFAULT_PITCH,      //Family and Pitch的设置
18. LPCWSTR("Wingdings"));            //字体名称(电脑中已装的)
19. SelectObject(m_HDC, font);                          //选择字体
20. wglUseFontOutlines(m_HDC,                           //当前HDC
21. 0,                               //从ASCII码第一个字符开始
22. 255,                             //字符数
23. m_Base,                          //第一个显示列表的名称
24. 0.1f,                            //字体光滑度，越小越光滑
25. 0.2f,                            //在z方向突出的距离(字体的厚度)
26. WGL_FONT_POLYGONS,               //使用多边形来生成字符，每个顶点具有独立法线
27. m_Gmf);                            //用于储存字形度量数据(高度，宽度等)
28. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. //自动生成纹理
4. glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
5. glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
6. glEnable(GL_TEXTURE_GEN_S);
7. glEnable(GL_TEXTURE_GEN_T);
8. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
9. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
10. glClearColor(0.0, 0.0, 0.0, 0.0);                   //黑色背景
11. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
12. glClearDepth(1.0);                                  //设置深度缓存
13. glEnable(GL_DEPTH_TEST);                            //启用深度测试
14. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
15. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
16. buildFont();                                        //创建字体
17. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glBindTexture(GL_TEXTURE_2D, m_Texture);
6. glTranslatef(1.1f*float(cos(m_Rot/16.0f)),
7. 0.8f*float(sin(m_Rot/20.0f)), m_Deep); //物体移动及控制大小
8. glRotatef(m_Rot, 1.0f, 0.0f, 0.0f);                 //绕x轴旋转
9. glRotatef(m_Rot*1.2f, 0.0f, 1.0f, 0.0f);            //绕y轴旋转
10. glRotatef(m_Rot*1.4f, 0.0f, 0.0f, 1.0f);            //绕z轴旋转
11. //输出文字到屏幕上
12. glPrint("N");
13. m_Rot += 0.1f;                                      //旋转变量增加
14. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. QString m_FileName;                             //图片的路径及文件名
20. GLuint m_Texture;                               //储存一个纹理
21. bool m_Light;                                   //光源的开/关
22. GLuint m_Fog;                                   //雾的模式
23. GLfloat m_xRot;                                 //x旋转角度
24. GLfloat m_yRot;                                 //y旋转角度
25. GLfloat m_xSpeed;                               //x旋转速度
26. GLfloat m_ySpeed;                               //y旋转速度
27. GLfloat m_Deep;                                 //深入屏幕的距离
28. };
29. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FileName = "D:/QtOpenGL/QtImage/Crate.bmp";        //应根据实际存放图片的路径进行修改
6. m_Light = false;
7. m_Fog = 0;
8. m_xRot = 0.0f;
9. m_yRot = 0.0f;
10. m_xSpeed = 0.0f;
11. m_ySpeed = 0.0f;
12. m_Deep = -5.0f;
13. QTimer *timer = new QTimer(this);                   //创建一个定时器
14. //将定时器的计时信号与updateGL()绑定
15. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
16. timer->start(10);                                   //以10ms为一个计时周期
17. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.5f, 0.5f, 0.5f, 1.0f);               //设置背景的颜色为雾气的颜色
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glEnable(GL_DEPTH_TEST);                            //启用深度测试
9. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
10. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
11. //光源部分
12. GLfloat LightAmbient[] = {0.5f, 0.5f, 0.5f, 1.0f};  //环境光参数
13. GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};  //漫散光参数
14. GLfloat LightPosition[] = {0.0f, 0.0f, 2.0f, 1.0f}; //光源位置
15. glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);     //设置环境光
16. glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);     //设置漫射光
17. glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);   //设置光源位置
18. glEnable(GL_LIGHT1);                                //启动一号光源
19. //雾部分
20. GLfloat fogColor[] = {0.5f, 0.5f, 0.5f, 1.0f};      //雾的颜色
21. glFogi(GL_FOG_MODE, GL_EXP);                        //设置雾气的初始模式
22. glFogfv(GL_FOG_COLOR, fogColor);                    //设置雾的颜色
23. glFogf(GL_FOG_DENSITY, 0.35);                       //设置雾的密度
24. glHint(GL_FOG_HINT, GL_DONT_CARE);                  //设置系统如何计算雾气
25. glFogf(GL_FOG_START, 1.0f);                         //雾的开始位置
26. glFogf(GL_FOG_END, 5.0f);                           //雾的结束位置
27. glEnable(GL_FOG);                                   //启动雾效果
28. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. static GLuint fogMode[] = {GL_EXP, GL_EXP2, GL_LINEAR};
4. switch (event->key())
5. {
6. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
7. fullscreen = !fullscreen;
8. if (fullscreen)
9. {
10. showFullScreen();
11. }
12. else
13. {
14. showNormal();
15. }
16. break;
17. case Qt::Key_Escape:                                //ESC为退出键
18. close();
19. break;
20. case Qt::Key_L:                                     //L为开启关闭光源的切换键
21. m_Light = !m_Light;
22. if (m_Light)
23. {
24. glEnable(GL_LIGHTING);                      //开启光源
25. }
26. else
27. {
28. glDisable(GL_LIGHTING);                     //关闭光源
29. }
30. break;
31. case Qt::Key_G:                                     //G为雾模式的切换键
32. m_Fog++;
33. if (m_Fog == 3)
34. {
35. m_Fog = 0;
36. }
37. glFogi(GL_FOG_MODE, fogMode[m_Fog]);
38. break;
39. case Qt::Key_PageUp:                                //PageUp按下使木箱移向屏幕内部
40. m_Deep -= 0.1f;
41. break;
42. case Qt::Key_PageDown:                              //PageDown按下使木箱移向观察者
43. m_Deep += 0.1f;
44. break;
45. case Qt::Key_Up:                                    //Up按下减少m_xSpeed
46. m_xSpeed -= 0.1f;
47. break;
48. case Qt::Key_Down:                                  //Down按下增加m_xSpeed
49. m_xSpeed += 0.1f;
50. break;
51. case Qt::Key_Right:                                 //Right按下减少m_ySpeed
52. m_ySpeed -= 0.1f;
53. break;
54. case Qt::Key_Left:                                  //Left按下增加m_ySpeed
55. m_ySpeed += 0.1f;
56. break;
57. }
58. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. void buildFont();                               //创建字体
19. void killFont();                                //删除显示列表
20. //输出字符串
21. void glPrint(GLuint x, GLuint y, const char *string, int set);
22. private:
23. bool fullscreen;                                //是否全屏显示
24. GLuint m_Base;                                  //储存绘制字体的显示列表的开始位置
25. GLfloat m_Cnt1;                                 //字体移动计数器1
26. GLfloat m_Cnt2;                                 //字体移动计数器2
27. QString m_FileName[2];                          //图片的路径及文件名
28. GLuint m_Texture[2];                            //储存两个纹理
29. };
30. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_Cnt1 = 0.0f;
6. m_Cnt2 = 0.0f;
7. m_FileName[0] = "D:/QtOpenGL/QtImage/Font.bmp";        //应根据实际存放图片的路径进行修改
8. m_FileName[1] = "D:/QtOpenGL/QtImage/Bumps.bmp";
9. QTimer *timer = new QTimer(this);                   //创建一个定时器
10. //将定时器的计时信号与updateGL()绑定
11. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
12. timer->start(10);                                   //以10ms为一个计时周期
13. }

1. MyGLWidget::~MyGLWidget()
2. {
3. killFont();                                         //删除显示列表
4. }

1. void MyGLWidget::buildFont()                            //创建位图字体
2. {
3. float cx, cy;                                       //储存字符的x、y坐标
4. m_Base = glGenLists(256);                           //创建256个显示列表
5. glBindTexture(GL_TEXTURE_2D, m_Texture[0]);         //选择字符纹理
6. for (int i=0; i<256; i++)                           //循环256个显示列表
7. {
8. cx = float(i%16)/16.0f;                         //当前字符的x坐标
9. cy = float(i/16)/16.0f;                         //当前字符的y坐标
10. glNewList(m_Base+i, GL_COMPILE);                //开始创建显示列表
11. glBegin(GL_QUADS);                          //使用四边形显示每一个字符
12. glTexCoord2f(cx, 1-cy-0.0625f);
13. glVertex2i(0, 0);
14. glTexCoord2f(cx+0.0625f, 1-cy-0.0625f);
15. glVertex2i(16, 0);
16. glTexCoord2f(cx+0.0625f, 1-cy);
17. glVertex2i(16, 16);
18. glTexCoord2f(cx, 1-cy);
19. glVertex2i(0, 16);
20. glEnd();                                    //四边形字符绘制完成
21. glTranslated(10, 0, 0);                     //绘制完一个字符，向右平移10个单位
22. glEndList();                                    //字符显示列表完成
23. }
24. }

1. void MyGLWidget::killFont()                             //删除显示列表
2. {
3. glDeleteLists(m_Base, 256);                         //删除256个显示列表
4. }

1. void MyGLWidget::glPrint(GLuint x, GLuint y,            //输入字符串
2. const char *string, int set)
3. {
4. if (set > 1)                                        //如果字符集大于1
5. {
6. set = 1;                                        //设置其为1
7. }
8. glBindTexture(GL_TEXTURE_2D, m_Texture[0]);         //绑定为字体纹理
9. glDisable(GL_DEPTH_TEST);                           //禁止深度测试
10. glMatrixMode(GL_PROJECTION);                        //选择投影矩阵
11. glPushMatrix();                                     //保存当前的投影矩阵
12. glLoadIdentity();                                   //重置投影矩阵
13. glOrtho(0, 640, 0, 480, -1, 1);                     //设置正投影的可视区域
14. glMatrixMode(GL_MODELVIEW);                         //选择模型观察矩阵
15. glPushMatrix();                                     //保存当前的模型观察矩阵
16. glLoadIdentity();                                   //重置模型观察矩阵
17. glTranslated(x, y ,0);                              //把字符原点移动到(x,y)位置
18. glListBase(m_Base-32+(128*set));                    //选择字符集
19. glCallLists(strlen(string), GL_BYTE, string);       //把字符串写到屏幕
20. glMatrixMode(GL_PROJECTION);                         //选择投影矩阵
21. glPopMatrix();                                      //设置为保存的矩阵
22. glMatrixMode(GL_MODELVIEW);                        //选择模型观察矩阵
23. glPopMatrix();                                      //设置为保存
24. glEnable(GL_DEPTH_TEST);                            //启用深度测试
25. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture[0] = bindTexture(QPixmap(m_FileName[0])); //载入位图并转换成纹理
4. m_Texture[1] = bindTexture(QPixmap(m_FileName[1]));
5. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
6. glClearColor(0.0, 0.0, 0.0, 0.0);                   //黑色背景
7. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
8. glClearDepth(1.0);                                  //设置深度缓存
9. glEnable(GL_DEPTH_TEST);                            //启用深度测试
10. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
11. glBlendFunc(GL_SRC_ALPHA, GL_ONE);                  //设置混合因子
12. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
13. buildFont();                                        //创建字体
14. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置当前的模型观察矩阵
5. glBindTexture(GL_TEXTURE_2D, m_Texture[1]);         //设置为图像纹理
6. glTranslatef(0.0f, 0.0f, -5.0f);                    //移入屏幕5.0单位
7. glRotatef(45.0f, 0.0f, 0.0f, 1.0f);                 //绕z轴旋转45度
8. glRotatef(m_Cnt1*30.0f, 1.0f, 1.0f, 0.0f);          //绕(1,1,0)轴旋转
9. glDisable(GL_BLEND);                                //关闭融合
10. glColor3f(1.0f, 1.0f, 1.0f);                        //设置颜色为白色
11. glBegin(GL_QUADS);                                  //绘制纹理四边形
12. glTexCoord2d(0.0f, 0.0f);
13. glVertex2f(-1.0f, 1.0f);
14. glTexCoord2d(1.0f, 0.0f);
15. glVertex2f(1.0f, 1.0f);
16. glTexCoord2d(1.0f, 1.0f);
17. glVertex2f(1.0f, -1.0f);
18. glTexCoord2d(0.0f, 1.0f);
19. glVertex2f(-1.0f, -1.0f);
20. glEnd();
21. glRotatef(90.0f, 1.0f, 1.0f, 0.0);                  //绕(1,1,0)轴旋转90度
22. glBegin(GL_QUADS);                                  //绘制第二个四边形，与第一个垂直
23. glTexCoord2d(0.0f, 0.0f);
24. glVertex2f(-1.0f, 1.0f);
25. glTexCoord2d(1.0f, 0.0f);
26. glVertex2f(1.0f, 1.0f);
27. glTexCoord2d(1.0f, 1.0f);
28. glVertex2f(1.0f, -1.0f);
29. glTexCoord2d(0.0f, 1.0f);
30. glVertex2f(-1.0f, -1.0f);
31. glEnd();
32. glEnable(GL_BLEND);                                 //启用混合
33. glLoadIdentity();                                   //重置视口
34. //根据字体位置设置颜色
35. glColor3f(1.0f*float(cos(m_Cnt1)), 1.0*float(sin(m_Cnt2)),
36. 1.0f-0.5f*float(cos(m_Cnt1+m_Cnt2)));
37. glPrint(int((280+250*cos(m_Cnt1))),
38. int(235+200*sin(m_Cnt2)), "NeHe", 0);
39. glColor3f(1.0*float(sin(m_Cnt2)), 1.0f-0.5f*float(cos(m_Cnt1+m_Cnt2)),
40. 1.0f*float(cos(m_Cnt1)));
41. glPrint(int((280+230*cos(m_Cnt2))),
42. int(235+200*sin(m_Cnt1)), "OpenGL", 1);
43. glColor3f(0.0f, 0.0f, 1.0f);
44. glPrint(int(240+200*cos((m_Cnt1+m_Cnt2)/5)), 2,
45. "Giuseppe D'Agata", 0);
46. glColor3f(1.0f, 1.0f, 1.0f);
47. glPrint(int(242+200*cos((m_Cnt1+m_Cnt2)/5)), 2,
48. "Giuseppe D'Agata", 0);
49. m_Cnt1 += 0.01f;                                   //增加两个计数器的值
50. m_Cnt2 += 0.0081f;
51. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class GLUquadric;
6. class MyGLWidget : public QGLWidget
7. {
8. Q_OBJECT
9. public:
10. explicit MyGLWidget(QWidget *parent = 0);
11. ~MyGLWidget();
12. protected:
13. //对3个纯虚函数的重定义
14. void initializeGL();
15. void resizeGL(int w, int h);
16. void paintGL();
17. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
18. private:
19. void glDrawCube();                              //绘制立方体
20. private:
21. bool fullscreen;                                //是否全屏显示
22. QString m_FileName;                             //图片的路径及文件名
23. GLuint m_Texture;                               //储存一个纹理
24. bool m_Light;                                   //光源的开/关
25. GLfloat m_xRot;                                 //x旋转角度
26. GLfloat m_yRot;                                 //y旋转角度
27. GLfloat m_xSpeed;                               //x旋转速度
28. GLfloat m_ySpeed;                               //y旋转速度
29. GLfloat m_Deep;                                 //深入屏幕的距离
30. int m_Part1;                                    //圆盘的起始角度
31. int m_Part2;                                    //圆盘的结束角度
32. int m_P1;                                       //增量1
33. int m_P2;                                       //增量2
34. GLUquadric *m_Quadratic;                        //二次几何体
35. GLuint m_Object;                                //绘制对象标示符
36. };
37. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_FileName = "D:/QtOpenGL/QtImage/Wall1.bmp";       //应根据实际存放图片的路径进行修改
6. m_Light = false;
7. m_xRot = 0.0f;
8. m_yRot = 0.0f;
9. m_xSpeed = 0.0f;
10. m_ySpeed = 0.0f;
11. m_Deep = -5.0f;
12. m_Part1 = 0;
13. m_Part2 = 0;
14. m_P1 = 0;
15. m_P2 = 1;
16. m_Object = 0;
17. QTimer *timer = new QTimer(this);                   //创建一个定时器
18. //将定时器的计时信号与updateGL()绑定
19. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
20. timer->start(10);                                   //以10ms为一个计时周期
21. }

1. MyGLWidget::~MyGLWidget()
2. {
3. gluDeleteQuadric(m_Quadratic);
4. }

1. void MyGLWidget::glDrawCube()
2. {
3. glBegin(GL_QUADS);                                  //开始绘制立方体
4. glNormal3f(0.0f, 1.0f, 0.0f);
5. glTexCoord2f(1.0f, 1.0f);
6. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(顶面)
7. glTexCoord2f(0.0f, 1.0f);
8. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(顶面)
9. glTexCoord2f(0.0f, 0.0f);
10. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左下(顶面)
11. glTexCoord2f(1.0f, 0.0f);
12. glVertex3f(1.0f, 1.0f, 1.0f);                   //右下(顶面)
13. glNormal3f(0.0f, -1.0f, 0.0f);
14. glTexCoord2f(0.0f, 0.0f);
15. glVertex3f(1.0f, -1.0f, 1.0f);                  //右上(底面)
16. glTexCoord2f(1.0f, 0.0f);
17. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左上(底面)
18. glTexCoord2f(1.0f, 1.0f);
19. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(底面)
20. glTexCoord2f(0.0f, 1.0f);
21. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(底面)
22. glNormal3f(0.0f, 0.0f, 1.0f);
23. glTexCoord2f(1.0f, 1.0f);
24. glVertex3f(1.0f, 1.0f, 1.0f);                   //右上(前面)
25. glTexCoord2f(0.0f, 1.0f);
26. glVertex3f(-1.0f, 1.0f, 1.0f);                  //左上(前面)
27. glTexCoord2f(0.0f, 0.0f);
28. glVertex3f(-1.0f, -1.0f, 1.0f);                 //左下(前面)
29. glTexCoord2f(1.0f, 0.0f);
30. glVertex3f(1.0f, -1.0f, 1.0f);                  //右下(前面)
31. glNormal3f(0.0f, 0.0f, -1.0f);
32. glTexCoord2f(0.0f, 0.0f);
33. glVertex3f(1.0f, -1.0f, -1.0f);                 //右上(后面)
34. glTexCoord2f(1.0f, 0.0f);
35. glVertex3f(-1.0f, -1.0f, -1.0f);                //左上(后面)
36. glTexCoord2f(1.0f, 1.0f);
37. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左下(后面)
38. glTexCoord2f(0.0f, 1.0f);
39. glVertex3f(1.0f, 1.0f, -1.0f);                  //右下(后面)
40. glNormal3f(-1.0f, 0.0f, 0.0f);
41. glTexCoord2f(1.0f, 1.0f);
42. glVertex3f(-1.0f, 1.0f, 1.0f);                  //右上(左面)
43. glTexCoord2f(0.0f, 1.0f);
44. glVertex3f(-1.0f, 1.0f, -1.0f);                 //左上(左面)
45. glTexCoord2f(0.0f, 0.0f);
46. glVertex3f(-1.0f, -1.0f, -1.0f);                //左下(左面)
47. glTexCoord2f(1.0f, 0.0f);
48. glVertex3f(-1.0f, -1.0f, 1.0f);                 //右下(左面)
49. glNormal3f(1.0f, 0.0f, 0.0f);
50. glTexCoord2f(1.0f, 1.0f);
51. glVertex3f(1.0f, 1.0f, -1.0f);                  //右上(右面)
52. glTexCoord2f(0.0f, 1.0f);
53. glVertex3f(1.0f, 1.0f, 1.0f);                   //左上(右面)
54. glTexCoord2f(0.0f, 0.0f);
55. glVertex3f(1.0f, -1.0f, 1.0f);                  //左下(右面)
56. glTexCoord2f(1.0f, 0.0f);
57. glVertex3f(1.0f, -1.0f, -1.0f);                 //右下(右面)
58. glEnd();                                            //立方体绘制结束
59. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glEnable(GL_DEPTH_TEST);                            //启用深度测试
9. glDepthFunc(GL_LEQUAL);                             //所作深度测试的类型
10. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
11. m_Quadratic = gluNewQuadric();                        //创建二次几何体
12. gluQuadricNormals(m_Quadratic, GLU_SMOOTH);           //使用平滑法线
13. gluQuadricTexture(m_Quadratic, GL_TRUE);              //使用纹理
14. //光源部分
15. GLfloat LightAmbient[] = {0.5f, 0.5f, 0.5f, 1.0f};  //环境光参数
16. GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};  //漫散光参数
17. GLfloat LightPosition[] = {0.0f, 0.0f, 2.0f, 1.0f}; //光源位置
18. glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);     //设置环境光
19. glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);     //设置漫射光
20. glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);   //设置光源位置
21. glEnable(GL_LIGHT1);                                //启动一号光源
22. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置模型观察矩阵
5. glTranslatef(0.0f, 0.0f, m_Deep);                    //移入屏幕5.0单位
6. glRotatef(m_xRot, 1.0f, 0.0f, 0.0f);                //绕x轴旋转
7. glRotatef(m_yRot, 0.0f, 1.0f, 0.0f);                //绕y轴旋转
8. glBindTexture(GL_TEXTURE_2D, m_Texture);            //选择纹理
9. switch(m_Object)
10. {
11. case 0:                                             //绘制立方体
12. glDrawCube();
13. break;
14. case 1:                                             //绘制圆柱体
15. glTranslatef(0.0f, 0.0f, -1.5f);
16. gluCylinder(m_Quadratic, 1.0f, 1.0f, 3.0f, 64, 64);
17. break;
18. case 2:                                             //绘制圆盘
19. gluDisk(m_Quadratic, 0.5f, 1.5f, 64, 64);
20. break;
21. case 3:                                             //绘制球
22. gluSphere(m_Quadratic, 1.3f, 64, 64);
23. break;
24. case 4:                                             //绘制圆锥
25. glTranslatef(0.0f, 0.0f, -1.5f);
26. gluCylinder(m_Quadratic, 1.0f, 0.0f, 3.0f, 64, 64);
27. break;
28. case 5:                                             //绘制部分圆盘
29. m_Part1 += m_P1;
30. m_Part2 += m_P2;
31. if (m_Part1 > 359)
32. {
33. m_P1 = 0;
34. m_Part1 = 0;
35. m_P2 = 1;
36. m_Part2 = 0;
37. }
38. if (m_Part2 > 359)
39. {
40. m_P1 = 1;
41. m_P2 = 0;
42. }
43. gluPartialDisk(m_Quadratic, 0.5f, 1.5f, 64, 64, m_Part1, m_Part2-m_Part1);
44. break;
45. }
46. m_xRot += m_xSpeed;                                 //x轴旋转
47. m_yRot += m_ySpeed;                                 //y轴旋转
48. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. break;
16. case Qt::Key_Escape:                                //ESC为退出键
17. close();
18. break;
19. case Qt::Key_L:                                     //L为开启关闭光源的切换键
20. m_Light = !m_Light;
21. if (m_Light)
22. {
23. glEnable(GL_LIGHTING);                      //开启光源
24. }
25. else
26. {
27. glDisable(GL_LIGHTING);                     //关闭光源
28. }
29. break;
30. case Qt::Key_Space:                                 //空格为物体的切换键
31. m_Object++;
32. if (m_Object == 6)
33. {
34. m_Object = 0;
35. }
36. break;
37. case Qt::Key_PageUp:                                //PageUp按下使木箱移向屏幕内部
38. m_Deep -= 0.1f;
39. break;
40. case Qt::Key_PageDown:                              //PageDown按下使木箱移向观察者
41. m_Deep += 0.1f;
42. break;
43. case Qt::Key_Up:                                    //Up按下减少m_xSpeed
44. m_xSpeed -= 0.1f;
45. break;
46. case Qt::Key_Down:                                  //Down按下增加m_xSpeed
47. m_xSpeed += 0.1f;
48. break;
49. case Qt::Key_Right:                                 //Right按下减少m_ySpeed
50. m_ySpeed -= 0.1f;
51. break;
52. case Qt::Key_Left:                                  //Left按下增加m_ySpeed
53. m_ySpeed += 0.1f;
54. break;
55. }
56. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. QString m_FileName;                             //图片的路径及文件名
20. GLuint m_Texture;                               //储存一个纹理
21. static const int MAX_PARTICLES = 1000;          //最大粒子数
22. static const GLfloat COLORS[12][3];             //彩虹的颜色
23. bool m_Rainbow;                                 //是否为彩虹模式
24. GLuint m_Color;                                 //当前的颜色
25. float m_Slowdown;                               //减速粒子
26. float m_xSpeed;                                 //x方向的速度
27. float m_ySpeed;                                 //y方向的速度
28. float m_Deep;                                   //移入屏幕的距离
29. struct Particle                                 //创建粒子结构体
30. {
31. bool active;                                //是否激活
32. float life;                                 //粒子生命
33. float fade;                                 //衰减速度
34. float r, g, b;                              //粒子颜色
35. float x, y, z;                              //位置坐标
36. float xi, yi, zi;                           //各方向速度
37. float xg, yg, zg;                           //各方向加速度
38. } m_Particles[MAX_PARTICLES];                   //存放1000个粒子的数组
39. };
40. #endif // MYGLWIDGET_H

1. const GLfloat MyGLWidget::COLORS[][3] =                 //彩虹的颜色
2. {
3. {1.0f, 0.5f, 0.5f}, {1.0f, 0.75f, 0.5f}, {1.0f, 1.0f, 0.5f},
4. {0.75f, 1.0f, 0.5f}, {0.5f, 1.0f, 0.5f}, {0.5f, 1.0f, 0.75f},
5. {0.5f, 1.0f, 1.0f}, {0.5f, 0.75f, 1.0f}, {0.5f, 0.5f, 1.0f},
6. {0.75f, 0.5f, 1.0f}, {1.0f, 0.5f, 1.0f}, {1.0f, 0.5f, 0.75f}
7. };
8. MyGLWidget::MyGLWidget(QWidget *parent) :
9. QGLWidget(parent)
10. {
11. fullscreen = false;
12. m_FileName = "D:/QtOpenGL/QtImage/Particle.bmp";    //应根据实际存放图片的路径进行修改
13. m_Rainbow = true;
14. m_Color = 0;
15. m_Slowdown = 2.0f;
16. m_xSpeed = 0.0f;
17. m_ySpeed = 0.0f;
18. m_Deep = -40.0f;
19. for (int i=0; i<MAX_PARTICLES; i++)                 //循环初始化所以粒子
20. {
21. m_Particles[i].active = true;                   //使所有粒子为激活状态
22. m_Particles[i].life = 1.0f;                     //所有粒子生命值为最大
23. //随机生成衰减速率
24. m_Particles[i].fade = float(rand()%100)/1000.0f+0.001;
25. //粒子的颜色
26. m_Particles[i].r = COLORS[int(i*(12.0f/MAX_PARTICLES))][0];
27. m_Particles[i].g = COLORS[int(i*(12.0f/MAX_PARTICLES))][1];
28. m_Particles[i].b = COLORS[int(i*(12.0f/MAX_PARTICLES))][2];
29. //粒子的初始位置
30. m_Particles[i].x = 0.0f;
31. m_Particles[i].y = 0.0f;
32. m_Particles[i].z = 0.0f;
33. //随机生成x、y、z轴方向速度
34. m_Particles[i].xi = float((rand()%50)-26.0f)*10.0f;
35. m_Particles[i].yi = float((rand()%50)-25.0f)*10.0f;
36. m_Particles[i].zi = float((rand()%50)-25.0f)*10.0f;
37. m_Particles[i].xg = 0.0f;                       //设置x方向加速度为0
38. m_Particles[i].yg = -0.8f;                      //设置y方向加速度为-0.8
39. m_Particles[i].zg = 0.0f;                       //设置z方向加速度为0
40. }
41. QTimer *timer = new QTimer(this);                   //创建一个定时器
42. //将定时器的计时信号与updateGL()绑定
43. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
44. timer->start(10);                                   //以10ms为一个计时周期
45. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. m_Texture = bindTexture(QPixmap(m_FileName));       //载入位图并转换成纹理
4. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
5. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //黑色背景
6. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
7. glClearDepth(1.0);                                  //设置深度缓存
8. glDisable(GL_DEPTH_TEST);                           //禁止深度测试
9. glEnable(GL_BLEND);                                 //启用融合
10. glBlendFunc(GL_SRC_ALPHA, GL_ONE);                  //设置融合因子
11. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //告诉系统对透视进行修正
12. glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
13. }

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置模型观察矩阵
5. glBindTexture(GL_TEXTURE_2D, m_Texture);
6. for (int i=0; i<MAX_PARTICLES; i++)                 //循环所以的粒子
7. {
8. if (m_Particles[i].active)                      //如果粒子为激活的
9. {
10. float x = m_Particles[i].x;                 //x轴位置
11. float y = m_Particles[i].y;                 //y轴位置
12. float z = m_Particles[i].z + m_Deep;        //z轴位置
13. //设置粒子颜色
14. glColor4f(m_Particles[i].r, m_Particles[i].g,
15. m_Particles[i].b, m_Particles[i].life);
16. glBegin(GL_TRIANGLE_STRIP);                 //绘制三角形带
17. glTexCoord2d(1, 1);glVertex3f(x+0.5f, y+0.5f, z);
18. glTexCoord2d(0, 1);glVertex3f(x-0.5f, y+0.5f, z);
19. glTexCoord2d(1, 0);glVertex3f(x+0.5f, y-0.5f, z);
20. glTexCoord2d(0, 0);glVertex3f(x-0.5f, y-0.5f, z);
21. glEnd();
22. //更新各方向坐标及速度
23. m_Particles[i].x += m_Particles[i].xi/(m_Slowdown*1000);
24. m_Particles[i].y += m_Particles[i].yi/(m_Slowdown*1000);
25. m_Particles[i].z += m_Particles[i].zi/(m_Slowdown*1000);
26. m_Particles[i].xi += m_Particles[i].xg;
27. m_Particles[i].yi += m_Particles[i].yg;
28. m_Particles[i].zi += m_Particles[i].zg;
29. m_Particles[i].life -= m_Particles[i].fade; //减少粒子的生命值
30. if (m_Particles[i].life < 0.0f)             //如果粒子生命值小于0
31. {
32. m_Particles[i].life = 1.0f;             //产生一个新粒子
33. m_Particles[i].fade = float(rand()%100)/1000.0f+0.003f;
34. m_Particles[i].r = colors[m_Color][0];  //设置颜色
35. m_Particles[i].g = colors[m_Color][1];
36. m_Particles[i].b = colors[m_Color][2];
37. m_Particles[i].x = 0.0f;                //粒子出现在屏幕*
38. m_Particles[i].y = 0.0f;
39. m_Particles[i].z = 0.0f;
40. //随机生成粒子速度
41. m_Particles[i].xi = m_xSpeed + float((rand()%60)-32.0f);
42. m_Particles[i].yi = m_ySpeed + float((rand()%60)-30.0f);
43. m_Particles[i].zi = float((rand()%60)-30.0f);
44. }
45. }
46. }
47. if (m_Rainbow)                                      //如果为彩虹模式
48. {
49. m_Color++;                                      //进行颜色的变换
50. if (m_Color > 11)
51. {
52. m_Color = 0;
53. }
54. }
55. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. updateGL();
16. break;
17. case Qt::Key_Escape:                                //ESC为退出键
18. close();
19. break;
20. case Qt::Key_Tab:                                   //Tab按下使粒子回到原点，产生爆炸
21. for (int i=0; i<MAX_PARTICLES; i++)
22. {
23. m_Particles[i].x = 0.0f;
24. m_Particles[i].y = 0.0f;
25. m_Particles[i].z = 0.0f;
26. //随机生成速度
27. m_Particles[i].xi = float((rand()%50)-26.0f)*10.0f;
28. m_Particles[i].yi = float((rand()%50)-25.0f)*10.0f;
29. m_Particles[i].zi = float((rand()%50)-25.0f)*10.0f;
30. }
31. break;
32. case Qt::Key_8:                                     //按下8增加y方向加速度
33. for (int i=0; i<MAX_PARTICLES; i++)
34. {
35. if (m_Particles[i].yg < 3.0f)
36. {
37. m_Particles[i].yg += 0.05f;
38. }
39. }
40. break;
41. case Qt::Key_2:                                     //按下2减少y方向加速度
42. for (int i=0; i<MAX_PARTICLES; i++)
43. {
44. if (m_Particles[i].yg > -3.0f)
45. {
46. m_Particles[i].yg -= 0.05f;
47. }
48. }
49. break;
50. case Qt::Key_6:                                     //按下6增加x方向加速度
51. for (int i=0; i<MAX_PARTICLES; i++)
52. {
53. if (m_Particles[i].xg < 3.0f)
54. {
55. m_Particles[i].xg += 0.05f;
56. }
57. }
58. break;
59. case Qt::Key_4:                                     //按下4减少x方向加速度
60. for (int i=0; i<MAX_PARTICLES; i++)
61. {
62. if (m_Particles[i].xg > -3.0f)
63. {
64. m_Particles[i].xg -= 0.05f;
65. }
66. }
67. break;
68. case Qt::Key_Plus:                                  //+ 号按下加速粒子
69. if (m_Slowdown > 1.0f)
70. {
71. m_Slowdown -= 0.05f;
72. }
73. break;
74. case Qt::Key_Minus:                                 //- 号按下减速粒子
75. if (m_Slowdown < 3.0f)
76. {
77. m_Slowdown += 0.05f;
78. }
79. break;
80. case Qt::Key_PageUp:                                //PageUp按下使粒子靠近屏幕
81. m_Deep += 0.5f;
82. break;
83. case Qt::Key_PageDown:                              //PageDown按下使粒子远离屏幕
84. m_Deep -= 0.5f;
85. break;
86. case Qt::Key_Return:                                //回车键为是否彩虹模式的切换键
87. m_Rainbow = !m_Rainbow;
88. break;
89. case Qt::Key_Space:                                 //空格键为颜色切换键
90. m_Rainbow = false;
91. m_Color++;
92. if (m_Color > 11)
93. {
94. m_Color = 0;
95. }
96. break;
97. case Qt::Key_Up:                                    //Up按下增加粒子y轴正方向的速度
98. if (m_ySpeed < 400.0f)
99. {
100. m_ySpeed += 5.0f;
101. }
102. break;
103. case Qt::Key_Down:                                  //Down按下减少粒子y轴正方向的速度
104. if (m_ySpeed > -400.0f)
105. {
106. m_ySpeed -= 5.0f;
107. }
108. break;
109. case Qt::Key_Right:                                 //Right按下增加粒子x轴正方向的速度
110. if (m_xSpeed < 400.0f)
111. {
112. m_xSpeed += 5.0f;
113. }
114. break;
115. case Qt::Key_Left:                                  //Left按下减少粒子x轴正方向的速度
116. if (m_xSpeed > -400.0f)
117. {
118. m_xSpeed -= 5.0f;
119. }
120. break;
121. }
122. }

1. #ifndef MYGLWIDGET_H
2. #define MYGLWIDGET_H
3. #include <QWidget>
4. #include <QGLWidget>
5. class MyGLWidget : public QGLWidget
6. {
7. Q_OBJECT
8. public:
9. explicit MyGLWidget(QWidget *parent = 0);
10. ~MyGLWidget();
11. protected:
12. //对3个纯虚函数的重定义
13. void initializeGL();
14. void resizeGL(int w, int h);
15. void paintGL();
16. void keyPressEvent(QKeyEvent *event);           //处理键盘按下事件
17. private:
18. bool fullscreen;                                //是否全屏显示
19. bool m_Masking;                                 //是否使用"<span style="font-size:12px;">掩模</span>"
20. bool m_Scene;                                   //控制绘制哪一层
21. GLfloat m_Rot;                                  //控制纹理滚动
22. QString m_FileName[5];                          //图片的路径及文件名
23. GLuint m_Texture[5];                            //储存五个纹理
24. };
25. #endif // MYGLWIDGET_H

1. MyGLWidget::MyGLWidget(QWidget *parent) :
2. QGLWidget(parent)
3. {
4. fullscreen = false;
5. m_Masking = true;
6. m_Scene = false;
7. m_FileName[0] = "D:/QtOpenGL/QtImage/Logo.bmp";     //纹理0
8. m_FileName[1] = "D:/QtOpenGL/QtImage/Mask1.bmp";    //<span style="font-size:12px;">掩模</span>纹理1,作为"<span style="font-size:12px;">掩模</span>"使用
9. m_FileName[2] = "D:/QtOpenGL/QtImage/Image1.bmp";   //纹理1
10. m_FileName[3] = "D:/QtOpenGL/QtImage/Mask2.bmp";    //<span style="font-size:12px;">掩模</span>纹理2,作为"<span style="font-size:12px;">掩模</span>"使用
11. m_FileName[4] = "D:/QtOpenGL/QtImage/Image2.bmp";   //纹理2
12. QTimer *timer = new QTimer(this);                   //创建一个定时器
13. //将定时器的计时信号与updateGL()绑定
14. connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
15. timer->start(10);                                   //以10ms为一个计时周期
16. }

1. void MyGLWidget::initializeGL()                         //此处开始对OpenGL进行所以设置
2. {
3. //载入位图并转换成纹理
4. for (int i=0; i<5; i++){
5. m_Texture[i] = bindTexture(QPixmap(m_FileName[i]));
6. }
7. glEnable(GL_TEXTURE_2D);                            //启用纹理映射
8. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //黑色背景
9. glShadeModel(GL_SMOOTH);                            //启用阴影平滑
10. glClearDepth(1.0);                                  //设置深度缓存<pre name="code" class="cpp"><pre name="code" class="cpp">}

1. void MyGLWidget::paintGL()                              //从这里开始进行所以的绘制
2. {
3. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
4. glLoadIdentity();                                   //重置模型观察矩阵
5. glTranslatef(0.0f, 0.0f, -2.0f);                    //移入屏幕2.0单位
6. glBindTexture(GL_TEXTURE_2D, m_Texture[0]);         //选择Logo纹理
7. glBegin(GL_QUADS);                                  //绘制纹理四边形
8. glTexCoord2f(0.0f, -m_Rot+0.0f);
9. glVertex3f(-1.1f, -1.1f, 0.0f);
10. glTexCoord2f(3.0f, -m_Rot+0.0f);
11. glVertex3f(1.1f, -1.1f, 0.0f);
12. glTexCoord2f(3.0f, -m_Rot+3.0f);
13. glVertex3f(1.1f, 1.1f, 0.0f);
14. glTexCoord2f(0.0f, -m_Rot+3.0f);
15. glVertex3f(-1.1f, 1.1f, 0.0f);
16. glEnd();
17. glEnable(GL_BLEND);                                 //启用混合
18. glDisable(GL_DEPTH_TEST);                           //禁用深度测试
19. if (m_Masking)                                      //是否启用"<span style="font-size:12px;">掩模</span>"
20. {
21. glBlendFunc(GL_DST_COLOR, GL_ZERO);             //使用黑白"<span style="font-size:12px;">掩模</span>"
22. }
23. if (m_Scene)
24. {
25. glTranslatef(0.0f, 0.0f, -1.0f);                //移入屏幕1.0单位
26. glRotatef(m_Rot*360, 0.0f, 0.0f, 1.0f);         //绕z轴旋转
27. if (m_Masking)                                  //"<span style="font-size:12px;">掩模</span>"是否打开
28. {
29. glBindTexture(GL_TEXTURE_2D, m_Texture[3]); //选择第二个"<span style="font-size:12px;">掩模</span>"纹理
30. glBegin(GL_QUADS);                          //开始绘制四边形
31. glTexCoord2f(0.0f, 0.0f);
32. glVertex3f(-1.1f, -1.1f, 0.0f);
33. glTexCoord2f(1.0f, 0.0f);
34. glVertex3f(1.1f, -1.1f, 0.0f);
35. glTexCoord2f(1.0f, 1.0f);
36. glVertex3f(1.1f, 1.1f, 0.0f);
37. glTexCoord2f(0.0f, 1.0f);
38. glVertex3f(-1.1f, 1.1f, 0.0f);
39. glEnd();
40. }
41. glBlendFunc(GL_ONE, GL_ONE);                    //把纹理2复制到屏幕上
42. glBindTexture(GL_TEXTURE_2D, m_Texture[4]);     //选择第二个纹理
43. glBegin(GL_QUADS);                              //绘制四边形
44. glTexCoord2f(0.0f, 0.0f);
45. glVertex3f(-1.1f, -1.1f, 0.0f);
46. glTexCoord2f(1.0f, 0.0f);
47. glVertex3f(1.1f, -1.1f, 0.0f);
48. glTexCoord2f(1.0f, 1.0f);
49. glVertex3f(1.1f, 1.1f, 0.0f);
50. glTexCoord2f(0.0f, 1.0f);
51. glVertex3f(-1.1f, 1.1f, 0.0f);
52. glEnd();
53. }
54. else
55. {
56. if (m_Masking)                                  //"<span style="font-size:12px;">掩模</span>"是否打开
57. {
58. glBindTexture(GL_TEXTURE_2D, m_Texture[1]); //选择第一个"<span style="font-size:12px;">掩模</span>"纹理
59. glBegin(GL_QUADS);                          //绘制四边形
60. glTexCoord2f(m_Rot+0.0f, 0.0f);
61. glVertex3f(-1.1f, -1.1f, 0.0f);
62. glTexCoord2f(m_Rot+4.0f, 0.0f);
63. glVertex3f(1.1f, -1.1f, 0.0f);
64. glTexCoord2f(m_Rot+4.0f, 4.0f);
65. glVertex3f(1.1f, 1.1f, 0.0f);
66. glTexCoord2f(m_Rot+0.0f, 4.0f);
67. glVertex3f(-1.1f, 1.1f, 0.0f);
68. glEnd();
69. }
70. glBlendFunc(GL_ONE, GL_ONE);                    //把纹理1复制到屏幕
71. glBindTexture(GL_TEXTURE_2D, m_Texture[2]);     //选择第一个纹理
72. glBegin(GL_QUADS);                              //绘制四边形
73. glTexCoord2f(m_Rot+0.0f, 0.0f);
74. glVertex3f(-1.1f, -1.1f, 0.0f);
75. glTexCoord2f(m_Rot+4.0f, 0.0f);
76. glVertex3f(1.1f, -1.1f, 0.0f);
77. glTexCoord2f(m_Rot+4.0f, 4.0f);
78. glVertex3f(1.1f, 1.1f, 0.0f);
79. glTexCoord2f(m_Rot+0.0f, 4.0f);
80. glVertex3f(-1.1f, 1.1f, 0.0f);
81. glEnd();
82. }
83. glEnable(GL_DEPTH_TEST);                            //启用深度测试
84. glDisable(GL_BLEND);                                //禁用混合
85. m_Rot += 0.002f;                                    //增加调整纹理滚动旋转变量
86. if (m_Rot > 1.0f)
87. {
88. m_Rot -= 1.0f;
89. }
90. }

1. void MyGLWidget::keyPressEvent(QKeyEvent *event)
2. {
3. switch (event->key())
4. {
5. case Qt::Key_F1:                                    //F1为全屏和普通屏的切换键
6. fullscreen = !fullscreen;
7. if (fullscreen)
8. {
9. showFullScreen();
10. }
11. else
12. {
13. showNormal();
14. }
15. updateGL();
16. break;
17. case Qt::Key_Escape:                                //ESC为退出键
18. close();
19. break;
20. case Qt::Key_Space:                                 //空格为场景(图层)的切换键
21. m_Scene = !m_Scene;
22. break;
23. case Qt::Key_M:                                     //M为是否"掩膜"的切换键
24. m_Masking = !m_Masking;
25. break;
26. }
27. }