OpenGL超级宝典笔记三 - 基础纹理1

纹理对象的使用：纹理图像数据的类型，图像数据的导入导出方式，纹理的使用过程：图像数据的加载，纹理参数的设置，纹理的绑定。

一、图像数据的分类：位图图像和像素图像

二、像素图像数据的包装：

在OpenGL中：使用4字节的行对齐方式，每一行补全到4的倍数，使用glPixelStorei(pname,param)可以改变或者恢复像素的存储方式

介绍常用的两组：内存<->缓冲区的压缩和解包

glPixcelStorei(GL_UNPACK_ALIGNMENT) ----图像数据从内存到缓冲区的解包设置

glPixcelStorei(GL_PACK_ALIGNMENT) ---- 图像数据从缓冲区到内存的封包设置

三、像素图的存储过程（从颜色缓冲区中获取图像保存为图片）

1、从颜色缓冲区读取像素数据到内存中：glReadPixcels(x,y,width,height,format,type,*pixcels)

pixcels:必须有足够的存储空间

format:指定颜色布局，类似GL_RGB,GL_RBGA之类

type:颜色分量的数据类型，类似GL_UNSIGHED_BYTE,GL_BYTE之类

2、从内存到硬盘的图像文件保存

四、像素图数据的获取过程（从硬盘到内存）

gltReadTGABits(szFileName,iWidth,iHeight,iComponents,eFormat)

获取：图片位图数据，宽高，iComponents:颜色成分的存储大小和压缩状况，eFormat:颜色布局

这些数据是位图数据从内存加载到缓冲区的时候，OpenGL需要的数据

五、纹理载入方式一（图像数据从内存到纹理缓冲区）：

glTexImage1D/glTexImage2D/glTexImage3D

glTexImage2D(target,level,internalformat,width,height,border,format,type,*data)

target:GL_TEXTURE_1D,GL_TEXTURE_2D,GL_TEXTURE_3D

level:指定mip贴图的层次

internalformat:就是上述获取到的iComponents的数据

border:为纹理贴图指定一个边界宽度

format,type,data:和用于把图像数据放入颜色缓冲区的glDrawPixcels函数对应的参数一致

六、纹理载入方式二（图像数据从颜色缓冲区读取到纹理缓冲区）：

glCopyTexImage2D(target,level,internalformat,x,y,width,height,border)

源缓冲区是通过glReadBuffer(mode)函数设置的。 mode为GL_FRONT,GL_LEFT 等参数

七、纹理更新操纵：更新替换原纹理的一部分数据

glTexSubImage2D(target,level,xOffset,yOffset,width,height,format,type,*data)

从颜色缓冲区中提取纹理作为数据去更新：

glCopyTexSubImage2D(target,level,xOffset,yOffset,width,height)

八、纹理对象的使用：由于使用glTexImage和glTexSubImage这样的函数加载和更新纹理太耗费内存，所以引用纹理对象

特点：纹理对象是允许我们一次加载一个以上的纹理状态（包括纹理图像）以及可以在它们之间快速切换的。

纹理对象的创建：glGenTextures(GLsizei n,GLuint* textures)

n:纹理对象数量

textures:不同纹理状态的句柄数组

纹理状态的绑定：glBindTexture(GLenum target,Gluint texture)

target:GL_TEXTURE_2D.....

texture:需要绑定的特定纹理状态

纹理对象的销毁：glDeleteTextures(n,textures)

纹理状态的确认：glIsTexure(GLuint texture)

九、纹理应用：

1、加载纹理数据

2、提供纹理坐标

s,t,r相当于x,y,z

3、设置纹理坐标的环绕模式（相对每个纹理坐标轴的）

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT)

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT)

环绕模式：

GL_REPEAT:超出1.0的对纹理进行重复

GL_CLAMP:使用纹理边界或者既定设置的边界颜色

GL_CLAMP_EDGE:使用纹理单元的最后一行或者一列数据

GL_CLAMP_BORDER:使用边界纹理单元

4、设置纹理的过滤（相对于拉伸和缩小的）

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

过滤模式：

GL_NEAREST:最邻近过滤，快速，但是如果纹理被拉伸过大会出现大片的斑驳像素

GL_LINEAR：线性过滤，开销大，但是效果比较好

十、综合运用的例子：可以旋转带光照纹理的金字塔

// Pyramid.cpp
// OpenGL SuperBible, Chapter 5
// Demonstrates Texture mapping a pyramid
// Program by Richard S. Wright Jr.

#include <GLTools.h>	// OpenGL toolkit
#include <GLMatrixStack.h>
#include <GLFrame.h>
#include <GLFrustum.h>
#include <GLBatch.h>
#include <GLGeometryTransform.h>

#include <math.h>
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

/////////////////////////////////////////////////////////////////////////////////
// An assortment of needed classes
GLShaderManager		shaderManager;
GLMatrixStack		modelViewMatrix;
GLMatrixStack		projectionMatrix;
GLFrame				cameraFrame;
GLFrame             objectFrame;
GLFrustum			viewFrustum;

GLBatch             pyramidBatch;

GLuint              textureID;

GLGeometryTransform	transformPipeline;
M3DMatrix44f		shadowMatrix;

void MakePyramid(GLBatch& pyramidBatch)
{
pyramidBatch.Begin(GL_TRIANGLES, 18, 1);
<span style="white-space:pre">	</span>//手动设置金字塔的顶点数据，包括位置，纹理坐标和光照法线向量
// Bottom of pyramid
pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3f(-1.0f, -1.0f, -1.0f);

pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
pyramidBatch.Vertex3f(1.0f, -1.0f, -1.0f);

pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
pyramidBatch.Vertex3f(1.0f, -1.0f, 1.0f);

pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
pyramidBatch.Vertex3f(-1.0f, -1.0f, 1.0f);

pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3f(-1.0f, -1.0f, -1.0f);

pyramidBatch.Normal3f(0.0f, -1.0f, 0.0f);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
pyramidBatch.Vertex3f(1.0f, -1.0f, 1.0f);

M3DVector3f vApex = { 0.0f, 1.0f, 0.0f };
M3DVector3f vFrontLeft = { -1.0f, -1.0f, 1.0f };
M3DVector3f vFrontRight = { 1.0f, -1.0f, 1.0f };
M3DVector3f vBackLeft = { -1.0f, -1.0f, -1.0f };
M3DVector3f vBackRight = { 1.0f, -1.0f, -1.0f };
M3DVector3f n;

// 根据三个点计算法线向量
m3dFindNormal(n, vApex, vFrontLeft, vFrontRight);
pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
pyramidBatch.Vertex3fv(vApex);		// Apex

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3fv(vFrontLeft);		// Front left corner

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
pyramidBatch.Vertex3fv(vFrontRight);		// Front right corner

m3dFindNormal(n, vApex, vBackLeft, vFrontLeft);
pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
pyramidBatch.Vertex3fv(vApex);		// Apex

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
pyramidBatch.Vertex3fv(vBackLeft);		// Back left corner

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3fv(vFrontLeft);		// Front left corner

m3dFindNormal(n, vApex, vFrontRight, vBackRight);
pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
pyramidBatch.Vertex3fv(vApex);				// Apex

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
pyramidBatch.Vertex3fv(vFrontRight);		// Front right corner

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3fv(vBackRight);			// Back right cornder

m3dFindNormal(n, vApex, vBackRight, vBackLeft);
pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
pyramidBatch.Vertex3fv(vApex);		// Apex

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
pyramidBatch.Vertex3fv(vBackRight);		// Back right cornder

pyramidBatch.Normal3fv(n);
pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
pyramidBatch.Vertex3fv(vBackLeft);		// Back left corner

pyramidBatch.End();
}
//获取纹理图像数据，并且设置纹理参数并得到一个纹理状态放入纹理对象中
bool loadTGATexture(const char *szFileName, GLenum minFilter, GLenum magFilter, GLenum wrapMode)
{
GLbyte *pBits;
int nWidth,nHeight,nComponents;
GLenum eFormat;

pBits = gltReadTGABits(szFileName, &nWidth, &nHeight, &nComponents, &eFormat);
if(pBits == NULL)
return false;
<span style="white-space:pre">	</span>//S,T轴上的纹理环绕模式
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
<span style="white-space:pre">	</span>//放大和缩小的过滤
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,minFilter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,magFilter);

glPixelStorei(GL_UNPACK_ALIGNMENT,1);		//图像数据解包，从内存区到缓存区
glTexImage2D(GL_TEXTURE_2D,0,nComponents,nWidth,nHeight,0,eFormat,GL_UNSIGNED_BYTE,pBits);

free(pBits);

if(minFilter == GL_LINEAR_MIPMAP_LINEAR ||
minFilter == GL_LINEAR_MIPMAP_NEAREST ||
minFilter == GL_NEAREST_MIPMAP_LINEAR ||
minFilter == GL_NEAREST_MIPMAP_NEAREST)
glGenerateMipmap(GL_TEXTURE_2D);

return true;
}

void SetupRC(){
glClearColor(0.7f,0.7f,0.7f,1.0f);

shaderManager.InitializeStockShaders();

glEnable(GL_DEPTH_TEST);

glGenTextures(1,&textureID);
glBindTexture(GL_TEXTURE_2D,textureID);
loadTGATexture("stone.tga",GL_LINEAR,GL_LINEAR,GL_CLAMP_TO_EDGE);

MakePyramid(pyramidBatch);
<span style="white-space:pre">	</span>//场景的照相机
cameraFrame.MoveForward(-7.0f);

}

void ShutdownRC(){
glDeleteTextures(1,&textureID);
}

void RenderScene(){
static GLfloat vLightPos[] = {1.0f,1.0f,0.0f};
static GLfloat vWhite[] = {1.0f,1.0f,1.0f,1.0f};

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

modelViewMatrix.PushMatrix();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);

M3DMatrix44f mObjectFrame;
objectFrame.GetCameraMatrix(mObjectFrame);
modelViewMatrix.MultMatrix(mObjectFrame);
<span style="white-space:pre">	</span>//在提交批绘制的时候，绑定我们需要使用的纹理
glBindTexture(GL_TEXTURE_2D,textureID);
shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,transformPipeline.GetModelViewMatrix(),
transformPipeline.GetProjectionMatrix(),vLightPos,vWhite,0);

pyramidBatch.Draw();

modelViewMatrix.PopMatrix();

glutSwapBuffers();
}

void SpecialKeys(int key,int x,int y){
if(key == GLUT_KEY_UP)
objectFrame.RotateWorld(m3dDegToRad(-5.0f),1.0f,0.0f,0.0f);
if(key == GLUT_KEY_DOWN)
objectFrame.RotateWorld(m3dDegToRad(5.0f),1.0f,0.0f,0.0f);
if(key == GLUT_KEY_LEFT)
objectFrame.RotateWorld(m3dDegToRad(-5.0f), 0.0f, 1.0f, 0.0f);

if(key == GLUT_KEY_RIGHT)
objectFrame.RotateWorld(m3dDegToRad(5.0f), 0.0f, 1.0f, 0.0f);

glutPostRedisplay();
}

void ChangeSize(int w,int h){
glViewport(0,0,w,h);
viewFrustum.SetPerspective(35.0f,float(w)/float(h),1.0f,500.0f);
projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
transformPipeline.SetMatrixStacks(modelViewMatrix,projectionMatrix);
}

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
glutInitWindowSize(800, 600);
glutCreateWindow("Pyramid");
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
glutDisplayFunc(RenderScene);

GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}

SetupRC();

glutMainLoop();

ShutdownRC();

return 0;
}