立方体环境贴图（Cube Mapping）之OpenGL原理

立方体纹理是一种特殊的纹理技术，它用6幅二维纹理图像构成一个以原点为中心的纹理立方体。对于每个片段，纹理坐标(s, t, r)被当作方向向量看待，每个纹理单元都表示从原点所看到的纹理立方体上的图像。

一个典型的立方环境贴图如下:

                                              图1

其中，前、后、左、右、上、下为环境图的各个方位截图。X, Y, Z为设置OpenGL中设置Cubemap贴图的方位。

里面有点奇怪，是为什么上和下的方向是反的？那个因为OpenGL最开始支持贴图的方式是倒过来的，也就是

                                                          图2

为了使得前图能够正向，因此我们对图2进行旋转，从而得到图1。

下面是实例代码：

main.cpp //里面有采用自己写一个TexutreManager类来解析.png图片，这里不贴这个类的代码了。

#pragma comment(lib, "glew32.lib")


#include <GL/glew.h>
#include "textfile.h"
#include <GL/glut.h>
#include <iostream>
#include "TextureManager.h"


using namespace std;


GLuint vShader, fShader; //顶点着色器对象


TextureManager gTM;
GLuint textureID;
GLuint programHandle;




float rotateAngle = 0.0f;
float rotateStep = 0.03f;


float positionData[] = 
{
	-1.0f, 1.0f, 1.0f,
	-1.0f, -1.0f, 1.0f,
	1.0f, -1.0f, 1.0f,
	1.0f, 1.0f, 1.0f,


	1.0f, 1.0f, -1.0f,
	1.0f, -1.0f, -1.0f,
	-1.0f, 1.0f, -1.0f,
	-1.0f, -1.0f, -1.0f
};






unsigned int indexData[] = {
	0, 1, 2, 3,
	6, 7, 4, 5,
	1, 3, 5, 7,
	0, 2, 4, 6,
	3, 5, 4, 2,
	1, 7, 6, 0
};


void initCubeMap()
{
	glGenTextures(1, &textureID);


	glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
	
	/*
	GLBITMAP* pos_x_img = gTM.GetTextureData("img/NEG_X.jpg");
	GLBITMAP* neg_x_img = gTM.GetTextureData("img/POS_X.jpg");
	GLBITMAP* pos_y_img = gTM.GetTextureData("img/NEG_Y.jpg");
	GLBITMAP* neg_y_img = gTM.GetTextureData("img/POS_Y.jpg");
	GLBITMAP* pos_z_img = gTM.GetTextureData("img/POS_Z.jpg");
	GLBITMAP* neg_z_img = gTM.GetTextureData("img/NEG_Z.jpg");
	*/


	GLBITMAP* pos_x_img = gTM.GetTextureData("img1/right.jpg");
	GLBITMAP* neg_x_img = gTM.GetTextureData("img1/left.jpg");
	GLBITMAP* pos_y_img = gTM.GetTextureData("img1/bottom.jpg");
	GLBITMAP* neg_y_img = gTM.GetTextureData("img1/top.jpg");
	GLBITMAP* pos_z_img = gTM.GetTextureData("img1/front.jpg");
	GLBITMAP* neg_z_img = gTM.GetTextureData("img1/back.jpg");
	


	


	if (pos_x_img == NULL
		|| neg_x_img == NULL
		|| pos_y_img == NULL
		|| neg_y_img == NULL
		|| pos_z_img == NULL
		|| neg_z_img == NULL)
	{
		cerr << "Error: Loading images for the cube map" << endl;
		exit(-1);
	}


	glEnable(GL_TEXTURE_CUBE_MAP);
	glActiveTexture(GL_TEXTURE0);


	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, pos_x_img->rgb_mode, pos_x_img->w, pos_x_img->h, 0,  pos_x_img->rgb_mode, GL_UNSIGNED_BYTE, pos_x_img->buf);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, neg_x_img->rgb_mode, neg_x_img->w, neg_x_img->h, 0, neg_x_img->rgb_mode, GL_UNSIGNED_BYTE, neg_x_img->buf);


	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, pos_y_img->rgb_mode, pos_y_img->w, pos_y_img->h, 0, pos_y_img->rgb_mode, GL_UNSIGNED_BYTE, pos_y_img->buf);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, neg_y_img->rgb_mode, neg_y_img->w, neg_y_img->h, 0, neg_y_img->rgb_mode, GL_UNSIGNED_BYTE, neg_y_img->buf);


	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, pos_z_img->rgb_mode, pos_z_img->w, pos_z_img->h, 0, pos_z_img->rgb_mode, GL_UNSIGNED_BYTE, pos_z_img->buf);
	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, neg_z_img->rgb_mode, neg_z_img->w, neg_z_img->h, 0, neg_z_img->rgb_mode, GL_UNSIGNED_BYTE, neg_z_img->buf);


	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}


void initShader(const char* VShaderFile, const char* FShaderFile)
{
	const GLubyte* renderer = glGetString(GL_RENDERER);
	const GLubyte* vendor = glGetString(GL_VENDOR);
	const GLubyte* version = glGetString(GL_VERSION);
	const GLubyte* glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);


	GLint major, minor;
	glGetIntegerv(GL_MAJOR_VERSION, &major);
	glGetIntegerv(GL_MINOR_VERSION, &minor);


	cout << "GL Vendor: " << vendor << endl;
	cout << "GL Renderer: " << renderer << endl;
	cout << "GL Version(string): " << version << endl;
	cout << "GL Version (integer): " << major << "." << minor << endl;
	cout << "GLSL Version: " << glslVersion << endl;


	vShader = glCreateShader(GL_VERTEX_SHADER);
	if (0 == vShader)
	{
		cerr << "ERROR: Create vertex shader failed" << endl;
		exit(1);
	}


	const GLchar* vShaderCode = textFileRead(VShaderFile);


	cout << "vShaderCode: " << vShaderCode << endl;


	const GLchar* vCodeArray[1] = {vShaderCode};
	glShaderSource(vShader, 1, vCodeArray, NULL);


	glCompileShader(vShader);


	GLint compileResult;
	glGetShaderiv(vShader, GL_COMPILE_STATUS, &compileResult);
	if (GL_FALSE == compileResult)
	{
		GLint logLen;
		glGetShaderiv(vShader, GL_INFO_LOG_LENGTH, &logLen);
		if (logLen > 0)
		{
			char* log = (char*)malloc(logLen);
			GLsizei written;


			glGetShaderInfoLog(vShader, logLen, &written, log);
			cerr << "vertex shader compile log: " << endl;
			cerr << log << endl;
			free(log);
		}
	}


	fShader = glCreateShader(GL_FRAGMENT_SHADER);
	if (0 == fShader)
	{
		cerr << "ERROR: Create fragment shader failed" << endl;
		exit(1);
	}


	const GLchar* fShaderCode = textFileRead(FShaderFile);




	cout << "fShaderCode: " << fShaderCode << endl;




	const GLchar* fCodeArray[1] = {fShaderCode};
	glShaderSource(fShader, 1, fCodeArray, NULL);


	glCompileShader(fShader);




	glGetShaderiv(fShader, GL_COMPILE_STATUS, &compileResult);
	if (GL_FALSE == compileResult)
	{
		GLint logLen;
		glGetShaderiv(fShader, GL_INFO_LOG_LENGTH, &logLen);
		if (logLen > 0)
		{
			char* log = (char*)malloc(logLen);
			GLsizei written;


			glGetShaderInfoLog(fShader, logLen, &written, log);


			cerr << "fragment shader compile log: " << endl;
			cerr << log << endl;
			free(log);
		}
	}




	programHandle = glCreateProgram();
	if (!programHandle)
	{
		cerr << "Error: create program fialed" << endl;
		exit(1);
	}


	glAttachShader(programHandle, vShader);
	glAttachShader(programHandle, fShader);


	glBindAttribLocation(programHandle, 0, "VertexPosition");
	glBindAttribLocation(programHandle, 1, "VertexColor");


	glLinkProgram(programHandle);


	GLint linkStatus;
	glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus);
	
	if (GL_FALSE == linkStatus)
	{
		cerr << "ERROR: link shader program failed" << endl;
		GLint logLen;
		glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &logLen);
		if (logLen > 0)
		{
			char* log = (char*)malloc(logLen);
			GLsizei written;
			glGetProgramInfoLog(programHandle, logLen, &written, log);
			cerr << "Program log: " << endl;
			cerr << log << endl;
		}
	}
	else 
	{
		glUseProgram(programHandle);
	}


}






void init()
{
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		cout << "Error initializing GLEW: " << glewGetErrorString(err) << endl;
	}


	initShader("basic.vert", "basic.frag");	


	initCubeMap();
}


void resize(int width, int height)		// Resize And Initialize The GL Window
{
	if (height==0)										// Prevent A Divide By Zero By
	{
		height=1;										// Making Height Equal One
	}


	glViewport(0,0,width,height);						// Reset The Current Viewport


	glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
	glLoadIdentity();									// Reset The Projection Matrix


	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);


	glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
	glLoadIdentity();									// Reset The Modelview Matrix


	glTranslatef(0.0f, 0.0f, -3.0f);
	//glRotatef(-180, 0.0, 0.0, 1.0);
}


void setUniforms()
{
	int textureLoc = glGetUniformLocation(programHandle, "cubemap1");
	glUniform1i(textureLoc, 0);


	int eyeposLoc = glGetUniformLocation(programHandle, "eyepos");
	glUniform3f(eyeposLoc, 0, 0.0, 1.0f);


}


void display()
{	
	setUniforms();


	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


	
	
	//glRotatef(rotateAngle, 0, 1, 0);


	glEnable(GL_TEXTURE_CUBE_MAP);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
	
	


	//glutSolidTeapot(1.0);
	glutSolidSphere(1.0, 60, 60);
	//glutSolidCube(1.0);


	
	/*
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, 3*sizeof(GL_FLOAT), positionData);


	glEnableClientState(GL_INDEX_ARRAY);
	glVertexPointer(1, GL_INT, sizeof(GL_INT), indexData);


	glDrawArrays(GL_QUADS, 0, 8);
	*/


	glutSwapBuffers();
}


void keyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 27:
		glDeleteShader(vShader);
		glUseProgram(0);
		break;
	}
}


void onTimer(int value)
{	
	rotateAngle =  rotateAngle + rotateStep;
	if (rotateAngle >= 360)
	{
		rotateAngle = 0;
	}


	display();


	glutTimerFunc(100, onTimer, 0);
}


int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GL_DOUBLE | GLUT_RGB);


	glutInitWindowSize(600, 600);
	glutInitWindowPosition(100, 100);


	glutCreateWindow("GLSL Test: Draw a triangle");


	init();


	glutDisplayFunc(display);
	
	glutTimerFunc(100, onTimer, 0);


	glutKeyboardFunc(keyboard);
	glutReshapeFunc(resize);


	glutMainLoop();


	return 0;
}

vert文件

uniform vec4 eyepos;
varying vec3 reflectvec;

void main(void)
{
   //vec4 pos = normalize(gl_ModelViewMatrix * gl_Vertex);
   //pos = pos / pos.w;
   
   vec4 pos = gl_ModelViewMatrix * gl_Vertex;
   
   vec3 eyevec = normalize(eyepos.xyz - pos.xyz);
   
   vec3 norm = normalize(gl_NormalMatrix * gl_Normal);
   
   reflectvec = reflect(-eyevec, norm);
   
   gl_Position = ftransform();
}

frag文件

uniform samplerCube cubemap1;
varying vec3 reflectvec;
 
void main(void)
{
   vec4 texcolor = textureCube(cubemap1, reflectvec.stp);
 
   gl_FragColor = texcolor;
}

运行效果：

各个纹理

front

back

left

right

top

bottom