[OpenGL] 二维游戏中的卷动地图

最新推荐文章于 2022-01-04 14:41:45 发布
最新推荐文章于 2022-01-04 14:41:45 发布
阅读量4.4k 收藏 18
点赞数 1
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJU_fish1996/article/details/52038412
版权

        卷动地图，也就是显示屏上只显示地图的一部分，随着玩家的走动，地图自动向走动方向卷动。在设计地图较大的二维游戏时，我们都不可避免地需要面对地图卷动这个问题。在切换场景方面，卷动地图和动态加载地图两者的结合，让整个游戏世界得以完整地呈现在玩家面前。

        在这一方面，比较高效的算法是卡马克卷轴算法，但是在这里，出于了解卷动地图的目的，我们只实现了最为朴素的卷动地图算法。也就是说，我们一次性绘制了整个地图，然后通过调整观察位置和视口大小，来实现卷动的效果。

        给出的样例中使用的地图是一张完整的图片。如果我们的地图不是一张完整的图片，而是网格布局的话，我们还可以考虑只绘制当前屏幕图片提高效率，这个优化会在之后的网格布局与碰撞检测中介绍。


    函数回顾

         首先，我们需要回顾一下OpenGL中几个重要函数的用法：

        1.glOrtho。该函数实现正投影。也就是，我们定义一个当前摄像机下的取景框大小，只有落在这个框里的物体才会显示。注意我们在glOrtho设置的参数非常重要，比如在这个例子中，我们设置的参数是glOrtho(-4, 4, -4, 4, -100, 100)。这也就意味着我们的屏幕坐标左下角是（-4.0，-4.0）,右上角是(4.0,4.0)，（注：正视时）我们需要利用这个数据来进行图形位置的摆放。

        2.glViewport。视口大小。在这里我们定义了视口的左下角坐标（一般为0,0）和视口长宽。可以这样理解，我们在此定义了取景框投影后的长与宽，然后屏幕也有长与宽，最终屏幕将截取屏幕大小的场景显示。一般而言，我们把这个视口大小设置的和窗体大小一样，就能恰好把所有物体包围。

        进一步而言，如果我们把视口大小设置的比窗体大，那么窗体只显示取景框中的一部分物体，利用这个，我们可以实现卷动地图效果：

       

        反言之，如果取景框大小比窗体小，那么就可以实现一个屏幕显示多个场景的效果：

       


      3.gluLookAt，定义了摄像机的位置以及朝向等。在卷动中，我们就是在不断移动这个摄像机的位置。



    自动卷动


        我们定义当人物走到屏幕3/4处时，触发卷动事件。在触发后，摄像机和人物一起向一个方向移动，注意移动速度最好 相同。当场景快要走出视野后，我们限制摄像机不再移动。当然，人物还是可以继续走动的，直到它走到地图边缘。

        自动卷动的原理很简单，但是，问题在于，什么是屏幕的3/4处，什么又是场景快要走出视野的状态？我们只讨论水平方向的移动来解释这个问题，竖直方向的移动是同理的。

        首先，我们定义glOrtho参数为-size_x,  size_x,  -size_y,  size_y，-100,  100； 卷动缩小的水平比例是x，竖直比例是y，也就是说，glViewport的参数是0,0,x*width,y*height,它将物体按这样的比例相对于窗体大小放大。

      

          在上图中，x = 3，也就是说，对于一张地图的水平方向，窗口只显示了它的1/3大小。当人物移动到红线的时候，触发卷动事件。

          在这里，首先要指出，中心坐标点 x = 0。图中一个方块的大小是2*size_x / x, 那么3/4个方块的大小就是3 / 2 * size_x / x。由于中心坐标x = 0,所以红线的坐标x = -size + 1.5*size/x。


         那么，什么时候卷动结束呢？或者说，什么时候我们不能继续移动摄像机了？

         我们用一些具体的例子来解释。

        ① x = 2。

         

        整个场景占了两个格子，而屏幕只显示其中一个格子。

        一开始，我们的摄像机位于黄色的位置，它把整个场景都包在取景框内，但是，由于glViewport的参数，初始状态下，我们在屏幕上看到的只是第一块格子。

       那么，场景即将离开的时候，我们希望在屏幕上恰好显示完整的第二块格子。这个时候，摄像机应该处在绿色的位置。

        一个格子的大小为2*size_/2 = size_x, 黄色处坐标为0，所以，摄像机的临界x值为：size_x。

       

     ②x = 3

       

        整个场景占了3个格子，而屏幕只显示1个格子。

       一个格子的大小为2*size_x/3 , 黄色处坐标为0，所以，摄像机的临界x值为：2*2*size_x/3 = 4*size_x/3。


    ③x = 4

       

        整个场景占了4个格子，而屏幕只显示1个格子。

        一个格子的大小为2*size_x/4 = size_x/2,黄色处坐标为0，所以，摄像机的临界x值为：3*size_x/2 .

       

        ……

       最终，得到对于任意的x，摄像机的临界x值为 2 * size_x - 2 * size_x / x。


       分辨率也会影响临界x值，在给出的例子中，我们考虑了分辨率的影响，涉及到的函数语句为wHeight = wWidth = min(width, height); 在相应的判断语句中也乘上了w/h系数，如果不希望考虑这一因素，直接把所有出现的w,h（宽度和高度）以及和它相关的语句删掉即可。两个卷动函数也可以合并为一个。


       

    代码

  test.h 

#pragma once 
#define GLUT_DISABLE_ATEXIT_HACK    
#include "GL/GLUT.H"    
void loadTex(int i, char *filename, GLuint* texture);//一般纹理  
void loadTex(int i, char *filename, GLuint* texture, unsigned char* backgroundColor);//透明纹理  

class sprite
{
public:
	//精灵位置（中心位置）
	float pos_x;
	float pos_y;

	//帧动画参数  
	int num = 96;//一共多少帧  
	int col = 12;//一行有多少帧  

	//精灵索引下标
	//前、左、右、后
	int index[4][3][2];

	//步长
	float step;

	//用于计数
	int count;
	int count2;
	int count3;
	
	//精灵贴图
	GLuint texture;

	//行走方向（枚举量）
	typedef enum { left, right, front, back }direction;

	//是否停止
	bool isStop = true;

	//行走方向
	direction dir = front;

	sprite(int _col,int _num,float x,float y,GLuint _texture,int* index,float _step);

	//快速索引绘制精灵
	void drawRect(GLuint texture, int i, int j);

	//绘制精灵
	void drawSprite();
};

texture.cpp 

#define _CRT_SECURE_NO_WARNINGS    
#include<stdio.h>    
#include<windows.h>    
#include"test.h"    
#define BITMAP_ID 0x4D42     


//读纹理图片      
static unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{

	FILE *filePtr;    // 文件指针      
	BITMAPFILEHEADER bitmapFileHeader;    // bitmap文件头      
	unsigned char    *bitmapImage;        // bitmap图像数据      
	int    imageIdx = 0;        // 图像位置索引      
	unsigned char    tempRGB;    // 交换变量      

								 // 以“二进制+读”模式打开文件filename       
	filePtr = fopen(filename, "rb");
	if (filePtr == NULL) {
		printf("file not open\n");
		return NULL;
	}
	// 读入bitmap文件图      
	fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);
	// 验证是否为bitmap文件      
	if (bitmapFileHeader.bfType != BITMAP_ID) {
		fprintf(stderr, "Error in LoadBitmapFile: the file is not a bitmap file\n");
		return NULL;
	}
	// 读入bitmap信息头      
	fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);
	// 将文件指针移至bitmap数据      
	fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
	// 为装载图像数据创建足够的内存      
	bitmapImage = new unsigned char[bitmapInfoHeader->biSizeImage];
	// 验证内存是否创建成功      
	if (!bitmapImage) {
		fprintf(stderr, "Error in LoadBitmapFile: memory error\n");
		return NULL;
	}

	// 读入bitmap图像数据      
	fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);
	// 确认读入成功      
	if (bitmapImage == NULL) {
		fprintf(stderr, "Error in LoadBitmapFile: memory error\n");
		return NULL;
	}
	//由于bitmap中保存的格式是BGR，下面交换R和B的值，得到RGB格式  

	for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx += 3) {
		tempRGB = bitmapImage[imageIdx];
		bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
		bitmapImage[imageIdx + 2] = tempRGB;
	}
	// 关闭bitmap图像文件     
	fclose(filePtr);
	return bitmapImage;
}

//读纹理图片      
static unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader, unsigned char* backgroundColor)
{

	FILE *filePtr;    // 文件指针      
	BITMAPFILEHEADER bitmapFileHeader;    // bitmap文件头      
	unsigned char    *bitmapImage;        // bitmap图像数据      
	int    imageIdx = 0;        // 图像位置索引      

								// 以“二进制+读”模式打开文件filename       
	filePtr = fopen(filename, "rb");
	if (filePtr == NULL) {
		printf("file not open\n");
		return NULL;
	}
	// 读入bitmap文件图      
	fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);
	// 验证是否为bitmap文件      
	if (bitmapFileHeader.bfType != BITMAP_ID) {
		fprintf(stderr, "Error in LoadBitmapFile: the file is not a bitmap file\n");
		return NULL;
	}
	// 读入bitmap信息头      
	fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);
	// 将文件指针移至bitmap数据      
	fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
	// 为装载图像数据创建足够的内存      
	bitmapImage = new unsigned char[bitmapInfoHeader->biSizeImage];
	// 验证内存是否创建成功      
	if (!bitmapImage) {
		fprintf(stderr, "Error in LoadBitmapFile: memory error\n");
		return NULL;
	}

	// 读入bitmap图像数据      
	fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);
	// 确认读入成功      
	if (bitmapImage == NULL) {
		fprintf(stderr, "Error in LoadBitmapFile: memory error\n");
		return NULL;
	}
	unsigned char*   bitmapData;   // 纹理数据   

	bitmapData = new unsigned char[bitmapInfoHeader->biSizeImage / 3 * 4];

	int count = 0;
	//添加alpha通道  
	for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx += 3) {
		bitmapData[count] = bitmapImage[imageIdx + 2];
		bitmapData[count + 1] = bitmapImage[imageIdx + 1];
		bitmapData[count + 2] = bitmapImage[imageIdx];
		if (bitmapData[count] >= backgroundColor[0]
			&& bitmapData[count + 1] >= backgroundColor[1]
			&& bitmapData[count + 2] >= backgroundColor[2]) {
			bitmapData[count + 3] = 0;
		}
		else bitmapData[count + 3] = 255;
		count += 4;
	}

	// 关闭bitmap图像文件     
	fclose(filePtr);
	return bitmapData;
}

//加载纹理的函数      
void loadTex(int i, char *filename, GLuint* texture)
{

	BITMAPINFOHEADER bitmapInfoHeader;                                 // bitmap信息头      
	unsigned char*   bitmapData;                                       // 纹理数据      

	bitmapData = LoadBitmapFile(filename, &bitmapInfoHeader);

	glBindTexture(GL_TEXTURE_2D, texture[i]);
	// 指定当前纹理的放大/缩小过滤方式      
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	glTexImage2D(GL_TEXTURE_2D,
		0,         //mipmap层次(通常为，表示最上层)       
		GL_RGB,    //我们希望该纹理有红、绿、蓝数据      
		bitmapInfoHeader.biWidth, //纹理宽带，必须是n，若有边框+2       
		bitmapInfoHeader.biHeight, //纹理高度，必须是n，若有边框+2       
		0, //边框(0=无边框, 1=有边框)       
		GL_RGB,    //bitmap数据的格式      
		GL_UNSIGNED_BYTE, //每个颜色数据的类型      
		bitmapData);    //bitmap数据指针      

}

//加载纹理的函数      
void loadTex(int i, char *filename, GLuint* texture, unsigned char* backgroundColor)
{

	BITMAPINFOHEADER bitmapInfoHeader;                                 // bitmap信息头      
	unsigned char*   bitmapData;                                       // 纹理数据      

	bitmapData = LoadBitmapFile(filename, &bitmapInfoHeader, backgroundColor);

	glBindTexture(GL_TEXTURE_2D, texture[i]);
	// 指定当前纹理的放大/缩小过滤方式      
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	glTexImage2D(GL_TEXTURE_2D,
		0,         //mipmap层次(通常为，表示最上层)       
		GL_RGBA,    //我们希望该纹理有红、绿、蓝、alpha数据      
		bitmapInfoHeader.biWidth, //纹理宽带，必须是n，若有边框+2       
		bitmapInfoHeader.biHeight, //纹理高度，必须是n，若有边框+2       
		0, //边框(0=无边框, 1=有边框)       
		GL_RGBA,    //bitmap数据的格式      
		GL_UNSIGNED_BYTE, //每个颜色数据的类型      
		bitmapData);    //bitmap数据指针      

}


sprite.cpp

#include"test.h"

sprite::sprite(int _col, int _num, float x, float y, GLuint _texture, int* _index,float _step)
{
	count = count2 = count3 = 0;
	col = _col;
	num = _num;
	pos_x = x;
	pos_y = y;
	texture = _texture;
	int cnt = 0;
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 3; j++) {
			for (int k = 0; k < 2; k++) {
				index[i][j][k] = _index[cnt++];
			}
		}
	}
	step = _step;
}
void sprite::drawRect(GLuint texture, int i, int j)
{
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, texture);  //选择纹理texture[status]       

	const GLfloat x1 = -0.5, x2 = 0.5;
	const GLfloat y1 = -0.5, y2 = 0.5;
	const GLfloat x = 1.0 / col, y = 1.0 / (num / col);
	const GLfloat point[4][2] = { { x1,y1 },{ x2,y1 },{ x2,y2 },{ x1,y2 } };
	const GLfloat dir[4][2] = { { j*x,1 - (i + 1)*y },{ (j + 1)*x,1 - (i + 1)*y },{ (j + 1)*x ,1 - i*y },{ j*x,1 - i*y } };
	glBegin(GL_QUADS);

	for (int k = 0; k < 4; k++) {
		glTexCoord2fv(dir[k]);
		glVertex2fv(point[k]);
	}
	glEnd();

	glDisable(GL_TEXTURE_2D);
}

void sprite::drawSprite()
{
	const int step = 50;
	count++;

	if (isStop) {
		if (dir == front) {
			drawRect(texture, index[0][1][0], index[0][1][1]);
		}
		else if (dir == back) {
			drawRect(texture, index[3][1][0], index[3][1][1]);
		}
		else if (dir == left) {
			drawRect(texture, index[1][1][0], index[1][1][1]);
		}
		else if (dir == right) {
			drawRect(texture, index[2][1][0], index[2][1][1]);
		}
	}
	else if (dir == front) {
		if (count <= step) {
			drawRect(texture, index[0][0][0], index[0][0][1]);
		}
		else if (count > step&&count <= step * 2) {
			drawRect(texture, index[0][1][0], index[0][1][1]);
		}
		else if (count > step * 2 && count <= step * 3) {
			drawRect(texture, index[0][2][0], index[0][2][1]);
		}
	}
	else if (dir == back) {
		if (count <= step) {
			drawRect(texture, index[3][0][0], index[3][0][1]);
		}
		else if (count > step && count <= step * 2) {
			drawRect(texture, index[3][1][0], index[3][1][1]);
		}
		else if (count > step * 2 && count <= step * 3) {
			drawRect(texture, index[3][2][0], index[3][2][1]);
		}
	}
	else if (dir == left) {
		if (count <= step) {
			drawRect(texture, index[1][0][0], index[1][0][1]);
		}
		else if (count > step && count <= step * 2) {
			drawRect(texture, index[1][1][0], index[1][1][1]);
		}
		else if (count > step * 2 && count <= step * 3) {
			drawRect(texture, index[1][2][0], index[1][2][1]);
		}
	}
	else if (dir == right) {
		if (count <= step) {
			drawRect(texture, index[2][0][0], index[2][0][1]);
		}
		else if (count > step && count <= step * 2) {
			drawRect(texture, index[2][1][0], index[2][1][1]);
		}
		else if (count > step * 2 && count <= step * 3) {
			drawRect(texture, index[2][2][0], index[2][2][1]);
		}
	}
	if (count%step == 0) {
		if (count2 == count3) {
			if (dir == front) {
				drawRect(texture, index[0][1][0], index[0][1][1]);
			}
			else if (dir == back) {
				drawRect(texture, index[3][1][0], index[3][1][1]);
			}
			else if (dir == left) {
				drawRect(texture, index[1][1][0], index[1][1][1]);
			}
			else if (dir == right) {
				drawRect(texture, index[2][1][0], index[2][1][1]);
			}
			isStop = true;

		}
		count3 = count2;
	}
	if (count == step * 3) {
		count = 0;
	}
}

main.cpp 

#define _CRT_SECURE_NO_WARNINGS    

#include <stdio.h>    
#include <string.h>    
#include<time.h>  
#include <stdlib.h>  
#include"test.h"    

#include <math.h>       /* for cos(), sin(), and sqrt() */      

GLuint texture[2];
//视区    
float whRatio;
int wHeight;
int wWidth;

//分辨率
float h=900, w=800;

//正投影
float size_x = 4.0f;
float size_y = 4.0f;

//分辨率中，宽的值是否更大
bool isWidthLarger;

//水平、竖直方向的卷轴大小与窗口大小比例
int x = 3;
int y = 2;

//视点    
float center[] = { 0, 0, 0 };
float eye[] = { 0, 0, 5 };

sprite *s;

inline float min(float x, float y)
{
	if (x < y) {
		isWidthLarger = false;
		return x;
	}
	else {
		isWidthLarger = true;
		return y;
	}
}
void drawRect(GLuint texture)
{
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, texture);  //选择纹理texture[status]       
	const GLfloat x1 = -0.5, x2 = 0.5;
	const GLfloat y1 = -0.5, y2 = 0.5;
	const GLfloat point[4][2] = { { x1,y1 },{ x2,y1 },{ x2,y2 },{ x1,y2 } };
	int dir[4][2] = { { 0,0 },{ 1,0 },{ 1,1 },{ 0,1 } };
	glBegin(GL_QUADS);

	for (int i = 0; i < 4; i++) {
		glTexCoord2iv(dir[i]);
		glVertex2fv(point[i]);
	}
	glEnd();
	glDisable(GL_TEXTURE_2D);
}


void drawScene()
{
	glPushMatrix();
	glScalef(size_x *2, size_y*2, 1);
	drawRect(texture[1]);
	glPopMatrix();
	
	glPushMatrix();
	glTranslatef(s->pos_x, s->pos_y, 2);
	glScalef(0.3f,0.3f, 1);
	s->drawSprite();
	glPopMatrix();
}

void updateView(int height, int width)
{

	glViewport(0, 0, width * x, height * y);
	glMatrixMode(GL_PROJECTION);//设置矩阵模式为投影         
	glLoadIdentity();   //初始化矩阵为单位矩阵            
	whRatio = (GLfloat)width / (GLfloat)height;  //设置显示比例       
	glOrtho(-size_x, size_x,-size_y,size_y, -100, 100); //正投影  
	glMatrixMode(GL_MODELVIEW);  //设置矩阵模式为模型      
}

void scroll_1()
{
	if (s->dir == sprite::right || s->dir == sprite::left) {
		if (s->dir == sprite::right&&s->pos_x>-size_x + 1.5*size_x / x*w/h&& s->pos_x<size_x) {
			eye[0] += s->step;
			center[0] += s->step;
			if (eye[0]>2 * size_x - 2 * size_x / x*w / h) {
				eye[0] = 2 * size_x - 2 * size_x / x*w / h;
				center[0] = 2 * size_x - 2 * size_x / x*w / h;
			}
		}
		else if (s->dir == sprite::left&&s->pos_x>-size_x&& s->pos_x<size_x - 1.5*size_x / x*w / h) {
			eye[0] -= s->step;
			center[0] -= s->step;
			if (eye[0]<0) {
				eye[0] = 0;
				center[0] = 0;
			}
		}
	}
	if (s->dir == sprite::front || s->dir == sprite::back) {
		if (s->dir == sprite::back&&s->pos_y>-size_y + 1.5*size_y /y && s->pos_y<size_y) {
			eye[1] += s->step;
			center[1] += s->step;
			if (eye[1]>2 * size_y - 2 * size_y / y) {
				eye[1] = 2 * size_y - 2 * size_y / y;
				center[1] = 2 * size_y - 2 * size_y / y;
			}
		}
		else if (s->dir == sprite::front&&s->pos_y>-size_y&&s->pos_y<size_y - 1.5*size_y / y) {
			eye[1] -= s->step;
			center[1] -= s->step;
			if (eye[1]<0) {
				eye[1] = 0;
				center[1] = 0;
			}
		}
	}
}

void scroll_2()
{
	if (s->dir == sprite::right || s->dir == sprite::left) {
		if (s->dir == sprite::right&&s->pos_x>-size_x + 1.5*size_x / x&& s->pos_x<size_x) {
			eye[0] += s->step;
			center[0] += s->step;
			if (eye[0]>2 * size_x - 2 * size_x / x) {
				eye[0] = 2 * size_x - 2 * size_x / x;
				center[0] = 2 * size_x - 2 * size_x / x;
			}
		}
		else if (s->dir == sprite::left&&s->pos_x>-size_x&& s->pos_x<size_x - 1.5*size_x / x) {
			eye[0] -= s->step;
			center[0] -= s->step;
			if (eye[0]<0) {
				eye[0] = 0;
				center[0] = 0;
			}
		}
	}
	if (s->dir == sprite::front || s->dir == sprite::back) {
		if (s->dir == sprite::back&&s->pos_y>-size_y + 1.5*size_y / y*w/h && s->pos_y<size_y) {
			eye[1] += s->step;
			center[1] += s->step;
			if (eye[1]>2 * size_y - 2 * size_y / y*w / h) {
				eye[1] = 2 * size_y - 2 * size_y / y*w / h;
				center[1] = 2 * size_y - 2 * size_y / y*w / h;
			}
		}
		else if (s->dir == sprite::front&&s->pos_y>-size_y&&s->pos_y<size_y - 1.5*size_y / y*w / h) {
			eye[1] -= s->step;
			center[1] -= s->step;
			if (eye[1]<0) {
				eye[1] = 0;
				center[1] = 0;
			}
		}
	}
}

void key(unsigned char k, int _x, int _y)
{
	s->count2++;
	switch (k)
	{
	case 'a': {
		s->dir = sprite::left;
		s->isStop = false;
		s->pos_x -= s->step;
		if (s->pos_x < -size_x)s->pos_x = -size_x;
		break;
	}
	case 'd': {
		s->dir = sprite::right;
		s->isStop = false;
		s->pos_x += s->step;
		if (s->pos_x > size_x)s->pos_x = size_x;
		break;
	}
	case 'w': {
		s->dir = sprite::back;
		s->isStop = false;
		s->pos_y += s->step;
		if (s->pos_y > size_y)s->pos_y = size_y;
		break;
	}
	case 's': {
		s->dir = sprite::front;
		s->isStop = false;
		s->pos_y -= s->step;
		if (s->pos_y < -size_y)s->pos_y = -size_y;
		break;
	}
	}
	if(isWidthLarger)scroll_1();
	else scroll_2();
	updateView(wHeight, wWidth); //更新视角    
}

void reshape(int width, int height)
{
	if (height == 0)      //如果高度为0        
	{
		height = 1;   //让高度为1（避免出现分母为0的现象）        
	}
	h = height;
	w = width;
	wHeight = height;
	wWidth = width;
	wHeight = wWidth = min(width, height);
	updateView(wHeight, wWidth); //更新视角   
	
}


void idle()
{
	glutPostRedisplay();
}

void init()
{
	srand(unsigned(time(NULL)));
	glEnable(GL_DEPTH_TEST);//开启深度测试     
	glEnable(GL_ALPHA_TEST);
	glAlphaFunc(GL_GREATER, 0.5);
	unsigned char color[3] = { 255,255,255 };
	glGenTextures(2, texture);
	loadTex(0, "1.bmp", texture,color);
	loadTex(1, "2.bmp", texture);
	if (w > h)isWidthLarger = true;
	else isWidthLarger = false;
	int index[] = {0,0,0,1,0,2,1,0,1,1,1,2,2,0,2,1,2,2,3,0,3,1,3,2};
	s = new sprite(12, 96, -1.5f, -1.5f, texture[0], index,0.06f);
}

void redraw()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清除颜色和深度缓存      
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();   //初始化矩阵为单位矩阵        
	gluLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2], 0, 1, 0);                // 场景（0，0，0）的视点中心 (0,5,50)，Y轴向上    
	glPolygonMode(GL_FRONT, GL_FILL);
	drawScene();//绘制场景     
	glutSwapBuffers();//交换缓冲区    
}

int main(int argc, char *argv[])
{

	glutInit(&argc, argv);//对glut的初始化           
	glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
	//初始化显示模式:RGB颜色模型，深度测试，双缓冲             
	glutInitWindowSize(w,h);//设置窗口大小           
	int windowHandle = glutCreateWindow("Simple GLUT App");//设置窗口标题             
	glutDisplayFunc(redraw); //注册绘制回调函数           
	glutReshapeFunc(reshape);   //注册重绘回调函数           
	glutKeyboardFunc(key); //注册按键回调函数
	glutIdleFunc(idle);//注册全局回调函数：空闲时调用         

	init();
	glutMainLoop();  // glut事件处理循环         
	return 0;
}

图片资源来自网络：



ZJU_fish1996
关注
专栏目录
【我的OpenGL学习进阶之旅】讲一讲GL_TEXTURE_2D和GL_TEXTURE_EXTERNAL_OES的区别
字节卷动
07-25 429
提供了对标准2D图像的处理能力，可以存储静态的贴图图像或者帧缓冲区的渲染结果。其使用二维的纹理坐标系，通过将纹理坐标映射到纹理图像上的对应位置，可以实现纹理贴图、纹理过滤、纹理环绕等操作。纹理的特点使用二维纹理坐标系进行操作；使用函数加载纹理数据；通过纹理过滤和纹理环绕等方式进行纹理的采样和处理；是 OpenGL 中的一个纹理目标类型，用于表示二维纹理。纹理是图形处理中的重要元素，用于将图像映射到几何体表面，从而实现复杂的图形效果。
【我的OpenGL学习进阶之旅】关于3D模型知识之：什么是obj文件和mtl文件
字节卷动
09-09 1592
OBJ 格式 和 MTL 格式 展示以及格式说明
OpenGL绘制简单地图
12-01
使用OpenGL绘制简单的地图 https://blog.csdn.net/ME__WE/article/details/84675155
[OpenGL] 二维游戏中的卷动地图----卷动地图，也就是显示屏上只显示地图的一部分，随着玩家的走动，地图自动向走动方向卷动。在设计地图较大的二维游戏时，我们都不可避免地需要面对地图卷动这个问题。
carlzhao531的专栏
11-08 863
卷轴式游戏地图实现
梦想博客
09-14 4300
卷轴式游戏地图实现，可以用键盘的方向键和鼠标的左键及滑轮全局浏览世界地图。
cocos2d-x游戏开发系列教程-超级玛丽07-CMGameMap(五)-地图卷动
weixin_30587025的博客
02-13 132
马里奥在平移的过程中，涉及到地图的卷动问题。在这个游戏里，地图比窗口大，窗口只是显示了地图的一部分，因此马里奥在移动的时候，移动到一定位置之后要卷动地图，否则马里奥移动到窗口右边之后......那结果将会很难看。卷动地图的原理在于，将地图的放在窗口的位置变化下。如下图所示地图在何时卷动呢？这个看我们的设计，在我们的代码中，卷动是这么实现的：当右键按下，也就是前进键按下时，马里奥就向前移动，移动...
Cocos2d-x游戏实例-《跑跑跑》制作教程（第四篇）——地图卷动
weixin_34099526的博客
09-06 116
上一篇我们已经把我们跑的主题体现出来了，但是，主角跑没多久就离开地图了，也离开屏幕了，这不靠谱啊喂，我们得让地图也动起来（难道我做这么长的地图是摆设么~）。 1.地图卷动规则 首先要定一个规则，地图怎么卷动？我们定义为这样，地图只会横向往左卷动，当主角超过屏幕中点的时候地图就开始卷动。最终的效果应该是这样的： 留意最左边，地图最左边已...
谈谈AVG游戏的Android移植（NScripter与吉里吉里）
qq_44906416的博客
04-22 1755
谈谈AVG游戏的Android移植（NScripter与吉里吉里）
3DSMAX中英文对照大全(从A-Z分类)
Zen
11-05 4517
A 　　Absolute Mode Transform Type-in绝对坐标方式变换输入 　　Absolute/Relative Snap Toggle Mode绝对/相对捕捉开关模式 　　ACIS Options ACIS选项 　　Activate活动；激活 　　Activate All Maps激活所有贴图 　　Activate Grid激活栅格；激活网格 　　Activate Grid Object激活网格对象；激活网格物体 　　Activate Home Grid激活主栅格；激活主网格 　　Act
地理地图/游戏地图与openGL
ShareUs的专栏
06-29 4263
-- 问题： OpenGL绘制三维地形图,地理地图; 基于OpenGL的地图渲染引擎设计与实现; OpenGL制作游戏的小地图; openGL将二维卫星地图渲染成三维地形图 ; Opengl绘制地图,OpenGL实现地图编辑器，制作简易地图; OpenGL渲染地理路线 建筑物等。 路线 建筑物等的坐标或经纬度数据？ > 地图与Opengl 使用opengles绘制灰度地形图- ...
2.5D游戏地图场景大图
11-18
网上找到的地图素材，换点积分……纯2.5D素材，请各位收下
opengl实现地形显示
04-18
opengl实现地形的显示，地形是由tin构造，有注释，通俗易懂
OPENGL绘制三维地形图
05-31
根据高程数据，绘制三维地形
OpenGL实现地图编辑器
07-02
OpenGL实现地图编辑器，和 Direct3D功能一样强大
仿游戏地图--卷轴式实现
09-14
包中含有VC6工程和VS2010工程两个版本，游戏背景用世界地图取代。可以用键盘的方向键和鼠标的左键及滑轮全局浏览世界地图。
Opengl绘制地图
Toxli的博客
09-12 8832
#include #include #include #include using namespace std; class MapPoint { public: double longitude; double latitude; }; class Polygon { public: vectorpoints; }; vector polys;   vector
OpenGL制作简易地图(二)
跑上岸晒太阳的鱼滴空间
07-12 2346
1.设置一个活动的block,从红方块出发,随机寻找兰方块,直到找到位置才停止. 2. 部分代码 #include "tree.h" #include "global.h" #include #include #include #include struct Tree_Node { NODE_ID id; POS pos; short status;
07二维数组生成扫雷游戏地图
shi_xiaobin的专栏
01-04 2603
运用二维数组生成扫雷游戏地图 要求：a,定义10*10的数组，把所有元素初始化为0 b,随机生成10个雷，不能重复（一定要有10个） -1表示雷 c,把以雷为中心的九宫格所有元素加1(雷除外) d,输出数组，观察是否正确 #include<stdio.h> #include<stdlib.h> #include<time.h> #define ROW 10 #de...
python 三维栅状图_基于OpenGL的二维矢量地图可视化技术研究
weixin_39662594的博客
12-06 212
基于OpenGL的二维矢量地图可视化技术研究电子地图显示速度直接影响地图用户的交互感受,一直是地图制图者关注的一个重点。本文从地图显示速度与适人化交互操作的关系出发,分析了GD(本文共4页)阅读全文>>监测数据保存在数据库中,可以查询显示为列表形式,为使...(本文共3页)阅读全文>>不知道走了多久,雪逐渐消失了。在他们上方是一个山谷,两侧是垂直的峭壁。在他们必须攀登的斜坡...
OpenGL三维游戏引擎优化与扩展研究
"这篇硕士学位论文主要探讨了基于OpenGL的三维游戏引擎的研究，作者刘志强，指导教师马建红，属于计算机应用技术专业。该研究针对OpenGL的特性，以及在3D游戏开发中的应用进行了深入探讨，并针对现有OpenGL游戏引擎...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值