第21课：线、反走样、正投影和简单的声音 (参照NeHe)
这次教程中，我们将介绍线、反走样、正投影和简单的声音，这是第一个大教程，希望这一课的东西大家能够喜欢（NeHe原文中有介绍计时器，但是Qt已经为我们封装好了计时器，所以这次教程中我省略了这部分，有兴趣了解VC中设置计时器的请点击这里）。
在这一课里，我们将学会绘制直接，使用反走样，正投影，基本的音效和一个简单的游戏逻辑，希望这里的东西可以让你高兴，毕竟我们会完成一个游戏！在这一课的结尾，你将获得一个叫“GRID CRAZY”的游戏，你的任务是走完每一段直线。这个程序有了一个基本游戏的一切要素：关卡，生命值，声明和一个游戏道具。
程序运行时效果如下：
下面进入教程：
我们这次将在第01课代码的基础上修改代码，这次是个大程序，我们一一解释新的内容和游戏逻辑，希望大家能理解和喜欢这第一个openGL游戏（虽然只是2D游戏）。首先打开项目文件(.pro文件)和myglwidget.h文件，将两个文件内容更改如下：
TARGET = QtOpenGL21
TEMPLATE = app
HEADERS += \
myglwidget.h
SOURCES += \
myglwidget.cpp \
main.cpp
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
QT += opengl \
multimedia#ifndef MYGLWIDGET_H
#define MYGLWIDGET_H
#include <QWidget>
#include <QGLWidget>
class QSound;
class MyGLWidget : public QGLWidget
{
Q_OBJECT
public:
explicit MyGLWidget(QWidget *parent = 0);
~MyGLWidget();
protected:
//对3个纯虚函数的重定义
void initializeGL();
void resizeGL(int w, int h);
void paintGL();
void keyPressEvent(QKeyEvent *event); //处理键盘按下事件
private:
void resetObjects(); //重置玩家和敌人信息
void updateData(); //更新下一帧数据
void buildFont(); //创建字体
void killFont(); //删除显示列表
//输出字符串
void glPrint(GLuint x, GLuint y, int set, const char *fmt, ...);
private:
bool fullscreen; //是否全屏显示
bool m_Vline[11][10]; //保存垂直方向的11根线条中,每根线条中的10段是否被走过
bool m_Hline[10][11]; //保存水平方向的11根线条中,每根线条中的10段是否被走过
bool m_Filled; //网格是否被填满
bool m_Gameover; //游戏是否结束
bool m_Anti; //是否反走样
int m_Delay; //敌人的暂停时间
int m_Adjust; //调整速度
int m_Lives; //玩家的生命
int m_Level; //内部的游戏难度等级
int m_Level2; //显示的游戏难度等级
int m_Stage; //游戏的关卡
static const int s_Steps[6]; //用来调节显示的速度
struct object //记录游戏中的对象
{
int fx, fy; //使移动变得平滑
int x, y; //当前游戏者的位置
float spin; //旋转角度
};
object m_Player; //玩家信息
object m_Enemy[9]; //最多9个敌人
object m_Hourglass; //宝物沙漏信息
QString m_FileName[2]; //图片的路径及文件名
GLuint m_Texture[2]; //储存两个纹理
GLuint m_Base; //字符显示列表的开始值
QSound *m_Sound; //保存吃到宝物后的计时音乐
};
#endif // MYGLWIDGET_H项目文件中，我们增加multimedia部分，这使得我们能够使用QSound等媒体播放对象。
myglwidget.h文件中，首先我们增加了2个布尔变量数组m_Vline和m_Hline，用于记录垂直方向和水平方向各110段线段是否走过。继续是3个布尔变量，当网格被填满时，m_Filled被设置为true而反之则为false；m_Gameover的作用易见，当它的值为true时，游戏结束；m_Anti指出抗锯齿功能是否打开，当设置为true时，该功能是打开着的。
接下来是5个整形变量和1个static const 整形数组，m_Delay用来减缓敌人的行动，其实就是当m_Delay小于某个值时，敌人不能移动（由于画面刷新很快，m_Delay变化也快，你是看不出敌人有很小一段时间没动的）。m_Adjust用来控制玩家和敌人移动的速度，其实就是控制玩家和敌人每一步能走多远，我们通过和下面的s_Steps[]数组配合一起完成这一控制目的。m_Lives保存了玩家的剩余生命值，m_Level保存了游戏内部的等级难度，m_Level2保存了显示出来的游戏难度，m_Stage保存了游戏的关卡（m_Level、m_Level2和m_Stage的区别后面大家会明白的，不用在这里纠结）。m_Steps[]保存了可供m_Adjust选择的数值。
然后我们定义了一个结构体来记录游戏中的对象。fx和fy记录每次在网格上移动我们的英雄和敌人的精确像素位置，x和y则记录着对象即将移动到网格交点是哪个。而最后一个变量spin用来使对象在z轴上选择。定义完后，我们就利用这个结构体创建我们的玩家对象，敌人对象（最多有9个所以是长度为9的数组）和宝物沙漏对象（m_Hourglass）。
还有我们需要载入两个纹理，所以有了m_FileName[2]和m_Texture[2。而m_Base储存字符显示列表的开始值，m_Sound用来指向一个QSound对象，该对象保存了吃到宝物后的计时音乐（注意声明QSound时需要在类前面加上class QSound声明）。最后是5个新的函数的声明，作用大家先看注释留个印象吧，后面会慢慢来介绍解释。
接下来，我们打开myglwidget.cpp，加上声明#include <QTimer>、#include <QSound>、#include <QTime>、#include <QCoreApplication>，在构造函数中对新增变量进行初始化并修改析构函数，具体代码如下：
const int MyGLWidget::s_Steps[] = {1, 2, 4, 5, 10, 20};
MyGLWidget::MyGLWidget(QWidget *parent) :
QGLWidget(parent)
{
fullscreen = false;
setFixedSize(640, 480); //设置固定的窗口大小
for (int i=0; i<11; i++) //初始化每个线段都没被走过
{
for (int j=0; j<11; j++)
{
if (i < 10)
{
m_Hline[i][j] = false;
}
if (j < 10)
{
m_Vline[i][j] = false;
}
}
}
m_Filled = false;
m_Gameover = false;
m_Anti = true;
m_Delay = 0;
m_Adjust = 3;
m_Lives = 5;
m_Level = 1;
m_Level2 = m_Level;
m_Stage = 1;
resetObjects(); //初始化玩家和敌人信息
m_Hourglass.fx = 0; //初始化宝物沙漏信息
m_Hourglass.fy = 0;
m_FileName[0] = "D:/QtOpenGL/QtImage/Font.bmp"; //应根据实际存放图片的路径进行修改
m_FileName[1] = "D:/QtOpenGL/QtImage/Image.bmp";
m_Sound = new QSound("D:/QtOpenGL/QtImage/Freeze.wav");
QTimer *timer = new QTimer(this); //创建一个定时器
//将定时器的计时信号与updateGL()绑定
connect(timer, SIGNAL(timeout()), this, SLOT(updateGL()));
timer->start(10); //以10ms为一个计时周期
}
MyGLWidget::~MyGLWidget()
{
killFont(); //删除显示列表
}我们来先看下我们几个新增函数的定义，说是新增，其实有3个已经是老面孔了，3个我们比较熟悉的函数代码如下：
void MyGLWidget::buildFont() //创建位图字体
{
float cx, cy; //储存字符的x、y坐标
m_Base = glGenLists(256); //创建256个显示列表
glBindTexture(GL_TEXTURE_2D, m_Texture[0]); //选择字符纹理
for (int i=0; i<256; i++) //循环256个显示列表
{
cx = float(i%16)/16.0f; //当前字符的x坐标
cy = float(i/16)/16.0f; //当前字符的y坐标
glNewList(m_Base+i, GL_COMPILE); //开始创建显示列表
glBegin(GL_QUADS); //使用四边形显示每一个字符
glTexCoord2f(cx, 1.0f-cy-0.0625f);
glVertex2i(0, 16);
glTexCoord2f(cx+0.0625f, 1.0f-cy-0.0625f);
glVertex2i(16, 16);
glTexCoord2f(cx+0.0625f, 1.0f-cy);
glVertex2i(16, 0);
glTexCoord2f(cx, 1.0f-cy);
glVertex2i(0, 0);
glEnd(); //四边形字符绘制完成
glTranslated(15, 0, 0); //绘制完一个字符，向右平移10个单位
glEndList(); //字符显示列表完成
}
}void MyGLWidget::killFont() //删除显示列表
{
glDeleteLists(m_Base, 256); //删除256个显示列表
}void MyGLWidget::glPrint(GLuint x, GLuint y, int set, const char *fmt, ...)
{
char text[256]; //保存字符串
va_list ap; //指向一个变量列表的指针
if (fmt == NULL) //如果无输入则返回
{
return;
}
va_start(ap, fmt); //分析可变参数
vsprintf(text, fmt, ap); //把参数值写入字符串
va_end(ap); //结束分析
if (set > 1) //如果字符集大于1
{
set = 1; //设置其为1
}
glEnable(GL_TEXTURE_2D); //启用纹理
glLoadIdentity(); //重置模型观察矩阵
glTranslated(x, y ,0); //把字符原点移动到(x,y)位置
glListBase(m_Base-32+(128*set)); //选择字符集
if (set == 0)
{
glScalef(1.5f, 2.0f, 1.0f); //如果是第一个字符集，放大字体
}
glCallLists(strlen(text), GL_BYTE, text); //把字符串写到屏幕
glDisable(GL_TEXTURE_2D); //禁用纹理
}下面来看看两个真正新面孔的函数，说一下updateData()函数时重点之一，具体代码如下：
void MyGLWidget::resetObjects() //重置玩家和敌人信息
{
m_Player.x = 0; //把玩家重置在屏幕的左上角
m_Player.y = 0;
m_Player.fx = 0;
m_Player.fy = 0;
for (int i=0; i<(m_Stage*m_Level); i++) //循环随机放置所有的敌人
{
m_Enemy[i].x = 5 + rand()%6;
m_Enemy[i].y = rand()%11;
m_Enemy[i].fx = m_Enemy[i].x * 60;
m_Enemy[i].fy = m_Enemy[i].y * 40;
}
}void MyGLWidget::updateData()
{
if (!m_Gameover) //如果游戏没有结束，则进行数据更新
{
for (int i=0; i<(m_Stage*m_Level); i++) //循环所有的敌人，敌人数由m_Stage×m_Level求得
{
//根据玩家的位置，让敌人追击玩家
if ((m_Enemy[i].x < m_Player.x) && (m_Enemy[i].fy == m_Enemy[i].y*40))
{
m_Enemy[i].x++;
}
if ((m_Enemy[i].x > m_Player.x) && (m_Enemy[i].fy == m_Enemy[i].y*40))
{
m_Enemy[i].x--;
}
if ((m_Enemy[i].y < m_Player.y) && (m_Enemy[i].fx == m_Enemy[i].x*60))
{
m_Enemy[i].y++;
}
if ((m_Enemy[i].y > m_Player.y) && (m_Enemy[i].fx == m_Enemy[i].x*60))
{
m_Enemy[i].y--;
}
//当前时间不为吃到宝物沙漏后的敌人静止时间，也不为敌人延迟时间(影响敌人的速度)
if ((m_Delay > (3-m_Level)) && (m_Hourglass.fx != 2))
{
m_Delay = 0; //重置宝物沙漏计时
for (int j=0; j<(m_Stage*m_Level); j++) //循环设置每个敌人的位置
{
//每个敌人调整位置，并调整旋转变量实现动画
if (m_Enemy[j].fx < m_Enemy[j].x*60)
{
m_Enemy[j].fx += s_Steps[m_Adjust];
m_Enemy[j].spin += s_Steps[m_Adjust];
}
if (m_Enemy[j].fx > m_Enemy[j].x*60)
{
m_Enemy[j].fx -= s_Steps[m_Adjust];
m_Enemy[j].spin -= s_Steps[m_Adjust];
}
if (m_Enemy[j].fy < m_Enemy[j].y*40)
{
m_Enemy[j].fy += s_Steps[m_Adjust];
m_Enemy[j].spin += s_Steps[m_Adjust];
}
if (m_Enemy[j].fy > m_Enemy[j].y*40)
{
m_Enemy[j].fy -= s_Steps[m_Adjust];
m_Enemy[j].spin -= s_Steps[m_Adjust];
}
}
}
//敌人的位置和玩家的位置相遇
if ((m_Enemy[i].fx == m_Player.fx) && (m_Enemy[i].fy == m_Player.fy))
{
m_Lives--; //如果是，生命值减1
if (m_Lives == 0) //如果生命值为0，则游戏结束
{
m_Gameover = true;
}
resetObjects(); //重置玩家和敌人信息
//播放死亡音乐并延迟2秒
QSound::play("D:/QtOpenGL/QtImage/Die.wav");
QTime time;
time.start();
while (time.elapsed() < 2000)
{
QCoreApplication::processEvents();
}
}
}
//调整玩家位置，使移动自然
if (m_Player.fx < m_Player.x*60)
{
m_Player.fx += s_Steps[m_Adjust];
m_Filled = false; //需要调整说明当前线段未走完，还不算网格填满
}
if (m_Player.fx > m_Player.x*60)
{
m_Player.fx -= s_Steps[m_Adjust];
m_Filled = false;
}
if (m_Player.fy < m_Player.y*40)
{
m_Player.fy += s_Steps[m_Adjust];
m_Filled = false;
}
if (m_Player.fy > m_Player.y*40)
{
m_Player.fy -= s_Steps[m_Adjust];
m_Filled = false;
}
}
if (m_Filled) //所有网格是否填满
{
//播放过关音乐并延迟4秒
QSound::play("D:/QtOpenGL/QtImage/Complete.wav");
QTime time;
time.start();
while (time.elapsed() < 4000)
{
QCoreApplication::processEvents();
}
m_Stage++; //增加游戏难度
if (m_Stage > 3) //如果当前的关卡大于3，则进入到下一难度等级
{
m_Stage = 1; //重置当前的关卡
m_Level++; //增加当前的难度等级
m_Level2++;
if (m_Level > 3)
{
m_Level = 3; //如果难度等级大于3，则不再增加
m_Lives++; //完成一局给玩家奖励一条生命
if (m_Lives > 5) //如果玩家有5条生命，则不再增加
{
m_Lives = 5;
}
}
}
resetObjects(); //重置玩家和敌人信息
for (int i=0; i<11; i++) //初始化每个线段都没被走过
{
for (int j=0; j<11; j++)
{
if (i < 10)
{
m_Hline[i][j] = false;
}
if (j < 10)
{
m_Vline[i][j] = false;
}
}
}
}
if ((m_Player.fx == m_Hourglass.x*60) //玩家吃到宝物沙漏
&& (m_Player.fy == m_Hourglass.y*40) && (m_Hourglass.fx == 1))
{
//循环播放一段计时音乐
m_Sound->setLoops(5);
m_Sound->play();
m_Hourglass.fx = 2; //设置fx为2，表示吃到宝物沙漏
m_Hourglass.fy = 0; //设置fy为0
}
m_Player.spin += 0.5f*s_Steps[m_Adjust]; //玩家旋转动画
if (m_Player.spin > 360.0f)
{
m_Player.spin -= 360.0f;
}
m_Hourglass.spin -= 0.25f*s_Steps[m_Adjust]; //宝物旋转动画
if (m_Hourglass.spin < 0.0f)
{
m_Hourglass.spin += 360.0f;
}
m_Hourglass.fy += s_Steps[m_Adjust]; //增加fy的值，当大于一定值时，产生宝物沙漏
if ((m_Hourglass.fx == 0) && (m_Hourglass.fy > 6000/m_Level))
{
//播放提示宝物沙漏产生的音乐
QSound::play("D:/QtOpenGL/QtImage/Hourglass.wav");
m_Hourglass.x = rand()%10 + 1;
m_Hourglass.y = rand()%11;
m_Hourglass.fx = 1; //fx=1表示宝物沙漏出现
m_Hourglass.fy = 0;
}
//玩家没有吃掉宝物沙漏，则过一段时间后会消失
if ((m_Hourglass.fx == 1) && (m_Hourglass.fy > 6000/m_Level))
{
m_Hourglass.fx = 0; //消失后重置宝物沙漏
m_Hourglass.fy = 0;
}
if ((m_Hourglass.fx == 2) && (m_Hourglass.fy > 500+(500*m_Level)))
{
m_Sound->stop(); //停止播放计时音乐
m_Hourglass.fx = 0; //重置宝物沙漏
m_Hourglass.fy = 0;
}
m_Delay++; //增加敌人的延迟计数器的值
}
进入重点的updateData()函数，它的作用是在每绘制一帧图像后，对游戏各部分数据进行适当准确的更新，为下一帧的绘图提供数据。首先，if语句判断游戏是否结束，没有结束就进入数据更新，进入游戏循环遍历每一个敌人。循环中，一开始我们利用4个if语句，让敌人根据玩家的位置去追击玩家。接下来的if ((m_Delay > (3-m_Level)) && (m_Hourglass.fx != 2))中，前一个语句表示，当前时间不为敌人的延迟时间（敌人在延迟时间中不运动，由于每秒画面帧数很多，延迟时间又很短，所以并看不来有延迟，通过设置延迟时间来减缓敌人的运动速度）；后一个语句表示，当前时间不为吃到宝物沙漏后敌人的静止时间。当if条件满足时，说明当前为运动时间，就通过4个if语句让敌人按照当前前进方向调整位置并调整旋转角度（前面4个if语句的目的是当敌人在某一交点时确定下一步的移动方向，而这后面4个if语句是为了实现敌人在相邻两交点之间的运动动画）。注意到我们每次移动的距离是由s_Steps[]和m_Adjust来确定的，这就是为什么m_Adjust能控制移动的速度。
然后我们判断敌人的位置和玩家的位置是否重合，如果重合，玩家会减少1点生命，并使玩家和敌人的位置重置，并利用QSound播放死亡音乐，如果这是玩家的生命减为0，则游戏结束，置m_Gameover为true。值得注意的是，在QSound::play()函数下面，我们设置了一个QTime，让它开始计时，并通过while循环不断检测当前的时间，如果达到2000ms则结束循环。我们这么做是为了在播放死亡音乐时，让程序产生2秒的等待，不会直接进入下一个画面。当然循环中，QCoreApplication::processEvents()这行也是十分重要的，它保证了在while循环过程，音乐播放事件能顺利执行。最后我们用4个if语句调整玩家的位置，让动画看起来自然，这里的机理和上面敌人后面4个if语句的机理是一样的。到这里，最开始的那个if语句就结束了。
下面一开始if语句判断m_Filled是否为true，为true说明已经顺利通过本关，播放通关音乐并产生4秒延迟（与上面同理）。然后我们提高游戏的关卡，重置所有的游戏变量（包括玩家、敌人、记录线段是否走过的数组），准备好进入下一关。到此，if语句结束。
接下来，判断玩家是否吃到宝物沙漏，如果是，则用m_Sound循环播放计时音乐，并修改m_Hourglass的数据信息，fx=2时表明被吃到，此时敌人会进入静止时间。
然后，我们让玩家的角度增加，以实现顺时针旋转的动画效果；让宝物沙漏角度较少，以实现逆时针旋转的动画效果。
最后部分是关于宝物沙漏的代码（我先说明下，m_Hourglass.fx等于0时表示不存在宝物沙漏，等于1时表示存在宝物沙漏，等于2时表示宝物沙漏被玩家吃了）。首先，让m_Hourglass.fy在每一帧都增加一定值。接着if语句判断当前不存在沙漏并且fy足够大（达到出现宝物沙漏的时间），如果是，就播放宝物沙漏出现的音乐，并随机生成宝物沙漏的位置，设置fx为1，fy为0。然后又一个if语句判断存在沙漏并且fy足够大（达到宝物沙漏消失的时间），如果是，就设置fx为0，fy为0，沙漏就会消失（不会被绘制出来）。最后一个if语句判断宝物沙漏被玩家吃了并且fy足够大（达到敌人静止时间结束），如果是，就用m_Sound结束播放的计时音乐，设置fx为0，fy为0，此时敌人的静止时间就会结束，可以重新动起来。
最终updateData()函数结尾，增加敌人的延迟计数器的m_Delay的值，只有当m_Delay足够大时，敌人才能运动，以此方式减缓了敌人的速度（在前面if语句中(m_Delay > (3-m_Level))这个语句就是实现这个功能的，当然这种减缓还与游戏难度等级建立的关系 ）。
然后，我们来修改一下initializeGL()函数和resizeGL()。initializeGL()中我们绑定了纹理，删掉了深度测试，启用了混合；resizeGL()中我们把透视投影换成了正投影（因为我们的游戏是2D游戏）。其它不多解释，具体代码如下：
void MyGLWidget::initializeGL() //此处开始对OpenGL进行所以设置
{
m_Texture[0] = bindTexture(QPixmap(m_FileName[0])); //载入位图并转换成纹理
m_Texture[1] = bindTexture(QPixmap(m_FileName[1]));
buildFont(); //创建字体
glClearColor(0.0, 0.0, 0.0, 0.0); //黑色背景
glShadeModel(GL_SMOOTH); //启用阴影平滑
glClearDepth(1.0); //设置深度缓存
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //告诉系统对透视进行修正
glEnable(GL_BLEND); //启用融合
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //设置融合因子
}void MyGLWidget::resizeGL(int w, int h) //重置OpenGL窗口的大小
{
glViewport(0, 0, (GLint)w, (GLint)h); //重置当前的视口
glMatrixMode(GL_PROJECTION); //选择投影矩阵
glLoadIdentity(); //重置投影矩阵
glOrtho(0.0f, 640, 480, 0.0f, -1.0f, 1.0f); //设置正投影
glMatrixMode(GL_MODELVIEW); //选择模型观察矩阵
glLoadIdentity(); //重置模型观察矩阵
}还有就要进入另一个重点paintGL()函数了，我会一一解释，具体代码如下：
void MyGLWidget::paintGL() //从这里开始进行所以的绘制
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存
glBindTexture(GL_TEXTURE_2D, m_Texture[0]); //旋转字符纹理
glColor3f(1.0f, 0.5f, 1.0f);
glPrint(207, 24, 0, "GRID CRAZY"); //绘制游戏名称"GRID CRAZY"
glColor3f(1.0f, 1.0f, 0.0f);
glPrint(20, 20, 1, "Level:%2i", m_Level2); //绘制当前的级别
glPrint(20, 40, 1, "Stage:%2i", m_Stage); //绘制当前级别的关卡
if (m_Gameover) //游戏是否结束
{
glColor3ub(rand()%255, rand()%255, rand()%255); //随机选择一种颜色
glPrint(472, 20, 1, "GAME OVER"); //绘制"GAME OVER"
glPrint(456, 40, 1, "PRESS SPACE"); //提示玩家按空格重新开始
}
for (int i=0; i<m_Lives-1; i++) //循环绘制玩家的剩余生命
{
glLoadIdentity(); //重置当前的模型观察矩阵
glTranslatef(490+(i*40.0f), 40.0f, 0.0f); //移动到屏幕右上角
//绘制剩余的生命图标
glRotatef(-m_Player.spin, 0.0f, 0.0f, 1.0f); //旋转动画
glColor3f(0.0f, 1.0f, 0.0f);
glBegin(GL_LINES);
glVertex2d(-5, -5);
glVertex2d(5, 5);
glVertex2d(5, -5);
glVertex2d(-5, 5);
glEnd();
glRotatef(-m_Player.spin*0.5f, 0.0f, 0.0f, 1.0f);
glColor3f(0.0f, 0.75f, 0.0f);
glBegin(GL_LINES);
glVertex2d(-7, 0);
glVertex2d(7, 0);
glVertex2d(0, -7);
glVertex2d(0, 7);
glEnd();
}
m_Filled = true; //在测试前，假定填充变量m_Filled为true
glLineWidth(2.0f); //设置线宽为2.0
glDisable(GL_LINE_SMOOTH); //禁用反走样
glLoadIdentity(); //重置当前的模型观察矩阵
for (int i=0; i<11; i++) //循环11根线
{
for (int j=0; j<11; j++) //循环每段线段
{
glColor3f(0.0f, 0.5f, 1.0f); //设置线为蓝色
if (m_Hline[i][j]) //是否走过
{
glColor3f(1.0f, 1.0f, 1.0f); //是，设置线为白色
}
if (i < 10) //绘制水平线
{
if (!m_Hline[i][j]) //如果当前线段没有走过，设置m_Filled为false
{
m_Filled = false;
}
glBegin(GL_LINES); //绘制当前的线段
glVertex2d(20+(i*60), 70+(j*40));
glVertex2d(80+(i*60), 70+(j*40));
glEnd();
}
glColor3f(0.0f, 0.5f, 1.0f); //设置线为蓝色
if (m_Vline[i][j]) //是否走过
{
glColor3f(1.0f, 1.0f, 1.0f); //是，设置线为白色
}
if (j < 10) //绘制垂直线
{
if (!m_Vline[i][j]) //如果当前线段没有走过，设置m_Filled为false
{
m_Filled = false;
}
glBegin(GL_LINES); //绘制当前的线段
glVertex2d(20+(i*60), 70+(j*40));
glVertex2d(20+(i*60), 110+(j*40));
glEnd();
}
glEnable(GL_TEXTURE_2D); //使用纹理映射
glColor3f(1.0f, 1.0f, 1.0f); //设置为白色
glBindTexture(GL_TEXTURE_2D, m_Texture[1]); //绑定纹理
if ((i < 10) && (j < 10)) //绘制走过的四边形
{
if (m_Hline[i][j] && m_Hline[i][j+1] //是否走过
&& m_Vline[i][j] && m_Vline[i+1][j])
{
glBegin(GL_QUADS); //是，绘制它
glTexCoord2f(float(i/10.0f)+0.1f, 1.0f-(float(j/10.0f)));
glVertex2d(20+(i*60)+59, 70+(j*40)+1);
glTexCoord2f(float(i/10.0f), 1.0f-(float(j/10.0f)));
glVertex2d(20+(i*60)+1, 70+(j*40)+1);
glTexCoord2f(float(i/10.0f), 1.0f-(float(j/10.0f)+0.1f));
glVertex2d(20+(i*60)+1, 70+(j*40)+39);
glTexCoord2f(float(i/10.0f)+0.1f, 1.0f-(float(j/10.0f)+0.1f));
glVertex2d(20+(i*60)+59, 70+(j*40)+39);
glEnd();
}
}
glDisable(GL_TEXTURE_2D);
}
}
glLineWidth(1.0f);
if (m_Anti) //是否启用反走样
{
glEnable(GL_LINE_SMOOTH);
}
if (m_Hourglass.fx == 1) //宝物沙漏是否存在
{
//是，把宝物沙漏绘制出来
glLoadIdentity();
glTranslatef(20.0f+(m_Hourglass.x*60), 70.0f+(m_Hourglass.y*40), 0.0f);
glRotatef(m_Hourglass.spin, 0.0f, 0.0f, 1.0f);
glColor3ub(rand()%255, rand()%255, rand()%255);
glBegin(GL_LINES);
glVertex2d(-5, -5);
glVertex2d(5, 5);
glVertex2d(5, -5);
glVertex2d(-5, 5);
glVertex2d(-5, 5);
glVertex2d(5, 5);
glVertex2d(-5, -5);
glVertex2d(5, -5);
glEnd();
}
//绘制玩家
glLoadIdentity();
glTranslatef(m_Player.fx+20.0f, //设置玩家的位置
m_Player.fy+70.0f, 0.0f);
glRotatef(m_Player.spin, 0.0f, 0.0f, 1.0f); //旋转动画
glColor3f(0.0f, 1.0f, 0.0f);
glBegin(GL_LINES);
glVertex2d(-5, -5);
glVertex2d(5, 5);
glVertex2d(5, -5);
glVertex2d(-5, 5);
glEnd();
glRotatef(m_Player.spin*0.5f, 0.0f, 0.0f, 1.0f);
glColor3f(0.0f, 0.75f, 0.0f);
glBegin(GL_LINES);
glVertex2d(-7, 0);
glVertex2d(7, 0);
glVertex2d(0, -7);
glVertex2d(0, 7);
glEnd();
//循环绘制所有敌人
for (int i=0; i<(m_Stage*m_Level); i++)
{
glLoadIdentity();
glTranslatef(m_Enemy[i].fx+20.0f, //设置敌人的位置
m_Enemy[i].fy+70.0f, 0.0f);
glColor3f(1.0f, 0.5f, 0.5f);
glBegin(GL_LINES);
glVertex2d(0, -7);
glVertex2d(-7, 0);
glVertex2d(-7, 0);
glVertex2d(0, 7);
glVertex2d(0, 7);
glVertex2d(7, 0);
glVertex2d(7, 0);
glVertex2d(0, -7);
glEnd();
glRotatef(m_Enemy[i].spin, 0.0f, 0.0f, 1.0f); //旋转动画
glColor3f(1.0f, 0.0f, 0.0f);
glBegin(GL_LINES);
glVertex2d(-7, -7);
glVertex2d(7, 7);
glVertex2d(-7, 7);
glVertex2d(7, -7);
glEnd();
}
updateData(); //更新下一帧的绘图数据
}if语句后，我们利用循环在屏幕的右上角绘制玩家的剩余生命。值得注意的是，我们会分两次进行绘制的（即有两个glBegin和glEnd），且两次绘制的角度、颜色、线的长短都不同，其实这只是为了让绘制的图标更好看罢了。还有，旋转的时候是根据spin的值进行旋转的，这就是为什么在updateData()我们要增加spin的值，通过这样的控制来旋转，我们可以实现旋转动画。
下面，我们来绘制网格。我们先假定m_Filled为true，表示当前全部网格已填满，接着我们把线的宽度设置为2.0。进入循环遍历每一段水平线段，并把线的颜色设置为蓝色，然后测试该线段是否走过，如果走过颜色就设置为白色。最后就可以把水平线段画出来了，位置的计算就不解释了。同理，我们可以画出垂直线段。
接下来我们检查网格中每个长方形的四条边是否都被走过，如果都被走过我们就绘制一个带纹理的四边形（检测过程其实就是检测m_Hline[i][j]、m_Hline[i][j+1]、m_Vline[i+1][j]、m_Vline[i+1][j+1]的值）。接着的if语句是判断m_Anti来设置是否启用直线反走样。
然后我们判断m_Hourglass.fx是否等于1（等于表示存在宝物沙漏），如果是，就绘制出宝物沙漏。再下面，我们就绘制我们的玩家了，绘制玩家的过程和之前的生命值相似，用两次绘制来让图标更好看些，当然还有利用spin实现旋转动画。再接下去，我们遍历所有敌人，与绘制玩家同样的道理和方法绘制出所有敌人。
最终，我们绘制完全部元素之后，调用updateData()函数，更新得到下一帧画面的数据。
最后，我们来补上键盘控制函数，具体代码如下：
void MyGLWidget::keyPressEvent(QKeyEvent *event)
{
switch (event->key())
{
case Qt::Key_F1: //F1为全屏和普通屏的切换键
fullscreen = !fullscreen;
if (fullscreen)
{
showFullScreen();
}
else
{
showNormal();
}
updateGL();
break;
case Qt::Key_Escape: //ESC为退出键
close();
break;
case Qt::Key_A: //A为开启禁用反走样的切换键
m_Anti = !m_Anti;
break;
case Qt::Key_Space: //空格为游戏结束时重置键
if (m_Gameover) //游戏结束则重置变量及数据
{
m_Gameover = false;
m_Filled = true;
m_Level = 1;
m_Level2 = m_Level;
m_Stage = 0;
m_Lives = 5;
updateData();
}
break;
case Qt::Key_Right: //按下向右右行一格
if ((m_Player.x < 10) && (m_Player.fx == m_Player.x*60)
&& (m_Player.fy == m_Player.y*40) && (!m_Filled))
{
m_Hline[m_Player.x][m_Player.y] = true;
m_Player.x++;
}
break;
case Qt::Key_Left: //按下向左左行一格
if ((m_Player.x > 0) && (m_Player.fx == m_Player.x*60)
&& (m_Player.fy == m_Player.y*40) && (!m_Filled))
{
m_Player.x--;
m_Hline[m_Player.x][m_Player.y] = true;
}
break;
case Qt::Key_Down: //按下向下下行一格
if ((m_Player.y < 10) && (m_Player.fx == m_Player.x*60)
&& (m_Player.fy == m_Player.y*40) && (!m_Filled))
{
m_Vline[m_Player.x][m_Player.y] = true;
m_Player.y++;
}
break;
case Qt::Key_Up: //按下向上上行一格
if ((m_Player.y > 0) && (m_Player.fx == m_Player.x*60)
&& (m_Player.fy == m_Player.y*40) && (!m_Filled))
{
m_Player.y--;
m_Vline[m_Player.x][m_Player.y] = true;
}
break;
}
}最后，上下左右方向键用于控制玩家的移动。这里的移动控制与前面updateDate()函数中，敌人根据玩家的位置调整前进方向是相似的，都是玩家必须在某一个交点处才能进行“移动”，而这里的“移动”只是确定了方向，并没有一次性就把位置变到下一个交点处。而是在updateData()中由已经确定了的方向，一点点移动到目标交点处，形成连续的动画。当然，每次移动后，要把走过的线段应对的布尔值置为true。
现在就可以运行程序查看效果了！（这次大教程内容真不少）
一点内容的补充：我们介绍一下反走样，在光栅图形显示器上绘制非水平且非垂直的直线或多边形边界时，或多或少会呈现锯齿状或台阶状外观。这是因为直线、多边形、色彩边界等是连续的，而光栅则是由离散的点组成，在光栅显示设备上表现直线、多边形等，必须在离散位置采样。由于采样不充分重建后造成的信息失真，就叫走样(aliasing)。而用于减少或消除这种效果的技术，就称为反走样(antialiasing)。
而我们的程序在正投影后，绘制图像就是在光栅图形显示器上绘制了；正常关闭反走样时，是看得到锯齿状线段的，但是由于我们游戏窗口设置为640×480，各元素看起来都比较小，我们肉眼很难捕捉到开启关闭反走样之间绘图的差异。