NeHe OpenGL教程第三十二课，DancingWind翻译

#include <windows.h>								
#include <stdio.h>								
#include <stdarg.h>								
#include <time.h>								
#include "NeHeGL.h"							

#pragma comment( lib, "opengl32.lib" )						// 在链接时连接Opengl32.lib库
#pragma comment( lib, "glu32.lib" )							// 链接glu32.lib库
#pragma comment( lib, "winmm.lib" )							// 链接winmm.lib库

#ifndef		CDS_FULLSCREEN							
#define		CDS_FULLSCREEN 4						
#endif									

void DrawTargets();								

GL_Window*	g_window;
Keys*		g_keys;

// 用户定义的变量
GLuint		base;								// 字体显示列表
GLfloat		roll;								// 旋转的云
GLint		level=1;								// 现在的等级
GLint		miss;								// 丢失的数
GLint		kills;								// 打到的数
GLint		score;								// 当前的分数
bool		game;								// 游戏是否结束?

typedef int (*compfn)(const void*, const void*);					// 定义用来比较的函数

struct objects {
	GLuint	rot;								// 旋转 (0-不转, 1-顺时针转, 2-逆时针转)
	bool	hit;								// 物体碰撞?
	GLuint	frame;								// 当前爆炸效果的动画帧
	GLuint	dir;								// 物体的方向 (0-左, 1-右, 2-上, 3-下)
	GLuint	texid;								// 物体材质 ID
	GLfloat	x;								// 物体 X 位置
	GLfloat y;								// 物体 Y 位置
	GLfloat	spin;								// 物体旋转
	GLfloat	distance;								// 物体距离
};

typedef struct									// 新建一个结构
{
	GLubyte	*imageData;							// 图片数据 (最大 32 位)
	GLuint	bpp;								// 图片颜色深度 每象素
	GLuint	width;								// 图片宽度
	GLuint	height;								// 图片高度
	GLuint	texID;								// 贴图材质 ID 用来选择一个材质
} TextureImage;									// 结构 名称

TextureImage textures[10];							// 定义10个材质

objects	object[30];							// 定义 30 个物体

struct dimensions {								// 物体维数
	GLfloat	w;								// 物体宽
	GLfloat h;								// 物体高
};

// 每个物体的大小: 蓝面, 水桶, 靶子, 可乐, 瓶子
dimensions size[5] = { {1.0f,1.0f}, {1.0f,1.0f}, {1.0f,1.0f}, {0.5f,1.0f}, {0.75f,1.5f} };

bool LoadTGA(TextureImage *texture, char *filename)					// 调入一个TGA 文件到内存
{
	GLubyte		TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0};			// (未)压缩的 TGA 头
	GLubyte		TGAcompare[12];						// 用来比较 TGA 头
	GLubyte		header[6];						// 首先 6 个有用的字节
	GLuint		bytesPerPixel;						// 每象素字节数在 TGA 文件使用
	GLuint		imageSize;						// 用来图片大小的存储
	GLuint		temp;							// 临时变量
	GLuint		type=GL_RGBA;						// 设置默认的 GL 模式 为 RBGA 

	FILE *file = fopen(filename, "rb");						// 打开 TGA 文件

	if(	file==NULL ||							// 文件是否已存在 ?
		fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) ||	// 是否读出12个字节?
		memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 ||			// 文件头是不是我们想要的 ?
		fread(header,1,sizeof(header),file)!=sizeof(header))			// 若正确则读下 6 个 Bytes
	{
		if (file == NULL)							// 文件是否已存在 ? 
			return FALSE;						// 返回错误
		else								// 否则
		{
			fclose(file);						// 若有任何错误, 关掉文件
			return FALSE;						// 返回错误
		}
	}

	texture->width  = header[1] * 256 + header[0];				// 定义 TGA 宽
	texture->height = header[3] * 256 + header[2];				// 定义 TGA 高

 	if(	texture->width	<=0 ||						// 若 宽<=0
		texture->height	<=0 ||						// 若 高<=0
		(header[4]!=24 && header[4]!=32))					// 若 TGA 是 24 or 32 位?
	{
		fclose(file);							// 若有任何错误, 关掉文件
		return FALSE;							// 返回错误
	}

	texture->bpp	= header[4];						// 取 TGA 的位每象素 (24 或 32)
	bytesPerPixel	= texture->bpp/8;						// 除以 8 得到字节每象素
	imageSize		= texture->width*texture->height*bytesPerPixel;		// 计算 所需内存为 TGA 数据

	texture->imageData=(GLubyte *)malloc(imageSize);				// 分配 内存 为 TGA 数据

	if(	texture->imageData==NULL ||						// 这个内存是否存在?
		fread(texture->imageData, 1, imageSize, file)!=imageSize)		// 图片大小与保留内存的大小想等 ?
	{
		if(texture->imageData!=NULL)					// 图片数据的调入
			free(texture->imageData);					// 若成功, 释放图象数据

		fclose(file);							// 关掉文件
		return FALSE;							// 返回错误
	}

	for(GLuint i=0; i<int(imageSize); i+=bytesPerPixel)				// 在图象数据里循环
	{									// 交换第1和第3 Bytes (’红’red 和 ’蓝’blue)
		temp=texture->imageData[i];						// 临时存储 图象的 ’i’
		texture->imageData[i] = texture->imageData[i + 2];			// 设 第1 Byte 得到变量 第3 Byte
		texture->imageData[i + 2] = temp;					// 设第3 Byte 得到变量 ’temp’ (第1 Byte 变量)
	}

	fclose (file);								// 关掉文件

	// 建立一个贴图材质从以上数据
	glGenTextures(1, &texture;[0].texID);						// 生成 OpenGL 材质 ID

	glBindTexture(GL_TEXTURE_2D, texture[0].texID);				// 绑定我们的材质
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);		// 线过滤器
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		// 线过滤器

	if (texture[0].bpp==24)							// 若 TGA 是24 位的
	{
		type=GL_RGB;							// 设 ’type’ 为 GL_RGB
	}

	glTexImage2D(GL_TEXTURE_2D, 0, type, texture[0].width, texture[0].height, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);

	return true;								// 材质建立成功, 返回正确
}

GLvoid BuildFont(GLvoid)							// 建立我们字体显示列表
{
	base=glGenLists(95);						// 建立 95 显示列表
	glBindTexture(GL_TEXTURE_2D, textures[9].texID);			// 绑我们字体材质
	for (int loop=0; loop<95; loop++)					// 循环在 95 列表
	{
		float cx=float(loop%16)/16.0f;				// X 位置 在当前字母
		float cy=float(loop/16)/8.0f;				// Y 位置 在当前字母

		glNewList(base+loop,GL_COMPILE);				// 开始建立一个列表
			glBegin(GL_QUADS);					// 用四边形组成每个字母
				glTexCoord2f(cx,         1.0f-cy-0.120f); glVertex2i(0,0);	// 质地 / 点 座标 (底 左)
				glTexCoord2f(cx+0.0625f, 1.0f-cy-0.120f); glVertex2i(16,0);	// 质地 / 点 座标 (底 右)
				glTexCoord2f(cx+0.0625f, 1.0f-cy);	  glVertex2i(16,16);	// 质地 / 点 座标 (顶 右)
				glTexCoord2f(cx,         1.0f-cy);	  glVertex2i(0,16);	// 质地 / 点 座标 (顶 左)
			glEnd();						// 完成建立我们的 四边形 (字母)
			glTranslated(10,0,0);				// 移到字体的右边
		glEndList();						// 完成建军立这个显示列表
	}								// 循环直到所有 256 完成建立
}

GLvoid glPrint(GLint x, GLint y, const char *string, ...)				// 输出在屏慕的位置
{
	char		text[256];						// 保存在我们的字符串
	va_list		ap;							// 到列表的指针

	if (string == NULL)							// 若文字为空
		return;								// 返回

	va_start(ap, string);							// 解析字符串
	    vsprintf(text, string, ap);						// 转换字符串
	va_end(ap);								// 结果的字符串

	glBindTexture(GL_TEXTURE_2D, textures[9].texID);				// 选择我们字体材质
	glPushMatrix();								// 存观看模式矩阵
	glLoadIdentity();								// 设观看模式矩阵
	glTranslated(x,y,0);							// 文字输出位置 (0,0 - 底 左-Bottom Left)
	glListBase(base-32);							// 选择字体设置
	glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);				// 输出显示列表中的文字
	glPopMatrix();								// 取出以前的模式矩阵
}

int Compare(struct objects *elem1, struct objects *elem2)			// 比较 函数
{
   if ( elem1->distance < elem2->distance)					// 若 第一个结构的距离小于第二个
      return -1;								// 返回 -1
   else if (elem1->distance > elem2->distance)				// 若 第一个结构的距离大于第二个
      return 1;								// 返回1
   else									// 否则 (若 距离相等)
      return 0;								// 返回 0
}

GLvoid InitObject(int num)							// 初始化一个物体
{
	object[num].rot=1;							// 顺时针旋转
	object[num].frame=0;						// 设爆炸效果动画帧为0
	object[num].hit=FALSE;						// 设点击检测为0
	object[num].texid=rand()%5;						// 设一个材质
	object[num].distance=-(float(rand()%4001)/100.0f);			// 随机距离
	object[num].y=-1.5f+(float(rand()%451)/100.0f);			// 随机 Y 位置
	// 随机开始 X 位置 基于物体的距离 和随机的延时量 (确定变量)
	object[num].x=((object[num].distance-15.0f)/2.0f)-(5*level)-float(rand()%(5*level));
	object[num].dir=(rand()%2);						// 选一个随机的方向

	if (object[num].dir==0)							// 若随机的方向正确
	{
		object[num].rot=2;							// 逆时针旋转
		object[num].x=-object[num].x;					// 开始在左边 (否定 变量)
	}

	if (object[num].texid==0)							// 蓝色天空表面
		object[num].y=-2.0f;						// 总是在大地上面旋转

	if (object[num].texid==1)						// 水桶(Bucket)
	{
		object[num].dir=3;						// 下落
		object[num].x=float(rand()%int(object[num].distance-10.0f))+((object[num].distance-10.0f)/2.0f);
		object[num].y=4.5f;					// 随机 X, 开始在屏模上方
	}

	if (object[num].texid==2)						// 靶子
	{
		object[num].dir=2;						// 开始向上飞
		object[num].x=float(rand()%int(object[num].distance-10.0f))+((object[num].distance-10.0f)/2.0f);
		object[num].y=-3.0f-float(rand()%(5*level));			// 随机 X, 开始在下面的大地 + 随机变量
	}

// 排序物体从距离:我们物体数组的开始地址 *** MSDN 代码修改为这个 TUT ***
// 各种的数按
// 各自的要素的
// 指针比较的函数
	qsort((void *) &object;, level, sizeof(struct objects), (compfn)Compare );
}

BOOL Initialize (GL_Window* window, Keys* keys)				// 任何 OpenGL 从这初始化
{
	g_window	= window;
	g_keys		= keys;

	srand( (unsigned)time( NULL ) );					// 使随机化事件

	if ((!LoadTGA(&textures;[0],"Data/BlueFace.tga")) ||			// 调入蓝面材质
		(!LoadTGA(&textures;[1],"Data/Bucket.tga")) ||			// 调入水桶材质
		(!LoadTGA(&textures;[2],"Data/Target.tga")) ||			// 调入靶子材质
		(!LoadTGA(&textures;[3],"Data/Coke.tga")) ||			// 调入 可乐材质
		(!LoadTGA(&textures;[4],"Data/Vase.tga")) ||			// 调入 花瓶 材质
		(!LoadTGA(&textures;[5],"Data/Explode.tga")) ||			// 调入 爆炸材质
		(!LoadTGA(&textures;[6],"Data/Ground.tga")) ||			// 调入 地面 材质
		(!LoadTGA(&textures;[7],"Data/Sky.tga")) ||			// 调入 天空 材质
		(!LoadTGA(&textures;[8],"Data/Crosshair.tga")) ||		// 调入 十字光标 材质
		(!LoadTGA(&textures;[9],"Data/Font.tga")))			// 调入 字符 材质
	{
		return FALSE;						// 若调入失败, 返回错误
	}

	BuildFont();								// 建立我们的字体显示列表

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);					// 黑色背景
	glClearDepth(1.0f);							// 安装深度缓冲器
	glDepthFunc(GL_LEQUAL);							// 深度的类型测试
	glEnable(GL_DEPTH_TEST);							// 打开深度测试
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);				// 打开 Alpha 混合
	glEnable(GL_BLEND);							// 打开混合
	glAlphaFunc(GL_GREATER,0.1f);						// 设 Alpha 测试
	glEnable(GL_ALPHA_TEST);							// 打开 Alpha 测试
	glEnable(GL_TEXTURE_2D);							// 打开材质贴图
	glEnable(GL_CULL_FACE);							// 去掉画物体的背面

	for (int loop=0; loop<30; loop++)					// 循环在 30 个物体Objects
		InitObject(loop);						// 初始化每个物体

	return TRUE;							// 返回正确 (设初值成功)
}

void Deinitialize (void)							// 任何user 结束初始化从这
{
	glDeleteLists(base,95);							// 删掉所有95 字体显示列表
}

void Selection(void)								// 这是选择正确
{
	GLuint	buffer[512];							//  设选择缓冲
	GLint	hits;								// 选择物体的数

	if (game)								// 游戏是否结束?
		return;							// 是，返回, 不在检测 Hits

	
	PlaySound("data/shot.wav",NULL,SND_ASYNC);				// 放音乐 Gun Shot

	// 视点的大小. [0] 是 <x>, [1] 是 <y>, [2] 是 <length>, [3] 是 <width>
	GLint	viewport[4];

	// 这是设视点的数组在屏幕窗口的位置
	glGetIntegerv(GL_VIEWPORT, viewport);
	glSelectBuffer(512, buffer);						// 告诉 OpenGL 使我们的数组来选择

	// 设 OpenGL 选择模式. 将不画东西. 物体 ID’的广度放在内存
	(void) glRenderMode(GL_SELECT);

	glInitNames();								// 设名字堆栈
	glPushName(0);								// Push 0 (最少一个) 在栈上

	glMatrixMode(GL_PROJECTION);						// 选投影矩阵
	glPushMatrix();								// 压入投影矩阵
	glLoadIdentity();								// 重设矩阵

	//  这是建一个矩阵使鼠标在屏幕缩放
	gluPickMatrix((GLdouble) mouse_x, (GLdouble) (viewport[3]-mouse_y), 1.0f, 1.0f, viewport);

	// 应用透视矩阵
	gluPerspective(45.0f, (GLfloat) (viewport[2]-viewport[0])/(GLfloat) (viewport[3]-viewport[1]), 0.1f, 100.0f);
	glMatrixMode(GL_MODELVIEW);							// 选择模型变换矩阵
	DrawTargets();								// 画目标
	glMatrixMode(GL_PROJECTION);						// 选择投影变换矩阵
	glPopMatrix();								// 取出投影矩阵
	glMatrixMode(GL_MODELVIEW);							// 选模式显示矩阵
	hits=glRenderMode(GL_RENDER);						// 切换模式, 找出有多少

	if (hits > 0)								// 若有大于0个 Hits
	{
		int	choose = buffer[3];					// 选择第一物体
		int	depth = buffer[1];						// 存它有多远

		for (int loop = 1; loop < hits; loop++)				// 循环所有检测到的物体
		{
			// 对于其它的物体
			if (buffer[loop*4+1] < GLuint(depth))
			{
				choose = buffer[loop*4+3];				// 选择更近的物体
				depth = buffer[loop*4+1];				// 保存它有多远
			}
		}

		if (!object[choose].hit)					// 如果物体还没有被击中
		{
			object[choose].hit=TRUE;				// 标记物体象被击中
			score+=1;						// 增加分数
			kills+=1;						// 加被杀数

			if (kills>level*5)					// 已有新的级?
			{
				miss=0;					// 失掉数回0
				kills=0;					// 设 Kills数为0
				level+=1;					// 加 Level
				if (level>30)				// 高过 30?
					level=30;				// 设 Level 为 30 (你是 God 吗?)
			}
		}
	}
}

void Update(DWORD milliseconds)							// 这里用来更新
{
	if (g_keys->keyDown[VK_ESCAPE])						// 按下 ESC?
	{
		TerminateApplication (g_window);					// 推出程序
	}

	if (g_keys->keyDown[' '] && game)					// 按下空格键?
	{
		for (int loop=0; loop<30; loop++)				// 循环所有的物体
			InitObject(loop);					// 初始化

		game=FALSE;						//设game为false 
		score=0;							// 分数为0
		level=1;							// 级别为1
		kills=0;							// 杀敌数为0
		miss=0;							// 漏过数为0
	}

	if (g_keys->keyDown[VK_F1])						// 按下f1?
	{
		ToggleFullscreen (g_window);				// 换到全屏模式
	}

	roll-=milliseconds*0.00005f;					// 云的旋转

	for (int loop=0; loop<level; loop++)					// 循环所有的物体
	{

		if (object[loop].rot==1)					
			object[loop].spin-=0.2f*(float(loop+milliseconds));	// 若顺时针,则顺时针旋转

		if (object[loop].rot==2)
			object[loop].spin+=0.2f*(float(loop+milliseconds));	// 若逆时针,则逆时针旋转

		if (object[loop].dir==1)					
			object[loop].x+=0.012f*float(milliseconds);		// 向右移动

		if (object[loop].dir==0)					
			object[loop].x-=0.012f*float(milliseconds);		// 向左移动

		if (object[loop].dir==2)					
			object[loop].y+=0.012f*float(milliseconds);		// 向上移动

		if (object[loop].dir==3)					
			object[loop].y-=0.0025f*float(milliseconds);		// 向下移动

		// 如果到达左边界,你没有击中,则增加丢失的目标数
		if ((object[loop].x<(object[loop].distance-15.0f)/2.0f) && (object[loop].dir==0) && !object[loop].hit)
		{
			miss+=1;						
			object[loop].hit=TRUE;					
		}

		// 如果到达右边界,你没有击中,则增加丢失的目标数
		if ((object[loop].x>-(object[loop].distance-15.0f)/2.0f) && (object[loop].dir==1) && !object[loop].hit)
		{
			miss+=1;						
			object[loop].hit=TRUE;				
		}

		// 如果到达下边界,你没有击中,则增加丢失的目标数
		if ((object[loop].y<-2.0f) && (object[loop].dir==3) && !object[loop].hit)
		{
			miss+=1;						
			object[loop].hit=TRUE;					
		}

		//如果到达左边界,你没有击中,则方向变为向下
		if ((object[loop].y>4.5f) && (object[loop].dir==2))		
			object[loop].dir=3;				
	}
}

void Object(float width,float height,GLuint texid)				// 画物体用需要的宽，高，材质
{
	glBindTexture(GL_TEXTURE_2D, textures[texid].texID);			// 选合适的材质
	glBegin(GL_QUADS);							// 开始画四边形
		glTexCoord2f(0.0f,0.0f); glVertex3f(-width,-height,0.0f);	
		glTexCoord2f(1.0f,0.0f); glVertex3f( width,-height,0.0f);	
		glTexCoord2f(1.0f,1.0f); glVertex3f( width, height,0.0f);	
		glTexCoord2f(0.0f,1.0f); glVertex3f(-width, height,0.0f);	
	glEnd();								
}

	void Explosion(int num)						// 画爆炸动画的1帧
{
	float ex = (float)((object[num].frame/4)%4)/4.0f;			// 计算爆炸时生成的x的纹理坐标
	float ey = (float)((object[num].frame/4)/4)/4.0f;			// 计算爆炸时生成的y的纹理坐标

	glBindTexture(GL_TEXTURE_2D, textures[5].texID);			// 选择爆炸的纹理
	glBegin(GL_QUADS);							
		glTexCoord2f(ex      ,1.0f-(ey      )); glVertex3f(-1.0f,-1.0f,0.0f);	
		glTexCoord2f(ex+0.25f,1.0f-(ey      )); glVertex3f( 1.0f,-1.0f,0.0f);	
		glTexCoord2f(ex+0.25f,1.0f-(ey+0.25f)); glVertex3f( 1.0f, 1.0f,0.0f);
		glTexCoord2f(ex      ,1.0f-(ey+0.25f)); glVertex3f(-1.0f, 1.0f,0.0f);	
	glEnd();								

	object[num].frame+=1;						// 加当前的爆炸动画帧
	if (object[num].frame>63)						// 是否已完成所有的16帧?
	{
		InitObject(num);						// 定义物体 (给新的变量)
	}
}

void DrawTargets(void)								// 画靶子
{
	glLoadIdentity();							
	glTranslatef(0.0f,0.0f,-10.0f);						// 移入屏幕 20 个单位
	for (int loop=0; loop<level; loop++)						// 循环在 9 个物体
	{

		glLoadName(loop);							// 给物体新名字
		glPushMatrix();							// 存矩阵
		glTranslatef(object[loop].x,object[loop].y,object[loop].distance);	// 物体的位置 (x,y)

		if (object[loop].hit)						// 若物体已被点击
		{
			Explosion(loop);						// 画爆炸动画
		}
		else								
		{
			glRotatef(object[loop].spin,0.0f,0.0f,1.0f);			// 旋转物体
			Object(size[object[loop].texid].w,size[object[loop].texid].h,object[loop].texid);	// 画物体
		}
		glPopMatrix();							// 弹出矩阵
	}
}

void Draw(void)								// 画我们的现场
{
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);			// 清除屏幕和深度缓冲
	glLoadIdentity();							// 重设矩阵

	glPushMatrix();								
	glBindTexture(GL_TEXTURE_2D, textures[7].texID);			// 选天空的材质
	glBegin(GL_QUADS);						
		glTexCoord2f(1.0f,roll/1.5f+1.0f); glVertex3f( 28.0f,+7.0f,-50.0f);	
		glTexCoord2f(0.0f,roll/1.5f+1.0f); glVertex3f(-28.0f,+7.0f,-50.0f);	
		glTexCoord2f(0.0f,roll/1.5f+0.0f); glVertex3f(-28.0f,-3.0f,-50.0f);	
		glTexCoord2f(1.0f,roll/1.5f+0.0f); glVertex3f( 28.0f,-3.0f,-50.0f);	

		glTexCoord2f(1.5f,roll+1.0f); glVertex3f( 28.0f,+7.0f,-50.0f);		
		glTexCoord2f(0.5f,roll+1.0f); glVertex3f(-28.0f,+7.0f,-50.0f);		
		glTexCoord2f(0.5f,roll+0.0f); glVertex3f(-28.0f,-3.0f,-50.0f);		
		glTexCoord2f(1.5f,roll+0.0f); glVertex3f( 28.0f,-3.0f,-50.0f);		

		glTexCoord2f(1.0f,roll/1.5f+1.0f); glVertex3f( 28.0f,+7.0f,0.0f);	
		glTexCoord2f(0.0f,roll/1.5f+1.0f); glVertex3f(-28.0f,+7.0f,0.0f);	
		glTexCoord2f(0.0f,roll/1.5f+0.0f); glVertex3f(-28.0f,+7.0f,-50.0f);	
		glTexCoord2f(1.0f,roll/1.5f+0.0f); glVertex3f( 28.0f,+7.0f,-50.0f);	

		glTexCoord2f(1.5f,roll+1.0f); glVertex3f( 28.0f,+7.0f,0.0f);		
		glTexCoord2f(0.5f,roll+1.0f); glVertex3f(-28.0f,+7.0f,0.0f);		
		glTexCoord2f(0.5f,roll+0.0f); glVertex3f(-28.0f,+7.0f,-50.0f);		
		glTexCoord2f(1.5f,roll+0.0f); glVertex3f( 28.0f,+7.0f,-50.0f);		
	glEnd();							

	glBindTexture(GL_TEXTURE_2D, textures[6].texID);			// 大地材质
	glBegin(GL_QUADS);							
		glTexCoord2f(7.0f,4.0f-roll); glVertex3f( 27.0f,-3.0f,-50.0f);	
		glTexCoord2f(0.0f,4.0f-roll); glVertex3f(-27.0f,-3.0f,-50.0f);	
		glTexCoord2f(0.0f,0.0f-roll); glVertex3f(-27.0f,-3.0f,0.0f);	
		glTexCoord2f(7.0f,0.0f-roll); glVertex3f( 27.0f,-3.0f,0.0f);	
	glEnd();								

	DrawTargets();								// 画我们的靶子
	glPopMatrix();								

	// 十字光标 (在光标里)
	RECT window;								// 用来存窗口位置
	GetClientRect (g_window->hWnd,&window;);					// 取窗口位置
	glMatrixMode(GL_PROJECTION);						
	glPushMatrix();								
	glLoadIdentity();						
	glOrtho(0,window.right,0,window.bottom,-1,1);				// 设置为正投影
	glMatrixMode(GL_MODELVIEW);						
	glTranslated(mouse_x,window.bottom-mouse_y,0.0f);			// 移动到当前鼠标位置
	Object(16,16,8);							// 画十字光标

	// 游戏状态 / 标题名称
	glPrint(240,450,"NeHe Productions");					// 输出 标题名称
	glPrint(10,10,"Level: %i",level);					// 输出 等级
	glPrint(250,10,"Score: %i",score);					// 输出 分数

	if (miss>9)								// 我们已丢失 10 个物体?
	{
		miss=9;								// 限制丢失是10个
		game=TRUE;							// 游戏结束
	}

	if (game)								// 游戏是否结束?
		glPrint(490,10,"GAME OVER");				// 结束消息
	else
		glPrint(490,10,"Morale: %i/10",10-miss);			// 输出剩余生命

	glMatrixMode(GL_PROJECTION);						
	glPopMatrix();								
	glMatrixMode(GL_MODELVIEW);						

	glFlush();								
}