OpenGL 学习笔记(十七)_opengl smooth out

一、OpenGL纹理

1、矩形纹理

        矩形纹理（GL_TEXTURE_RECTANGLE），纹理目标模式的工作方式和GL_TEXTURE_2D非常相似，但有几点不同；

• 首先，它不能进行MIP贴图，意味着只能加载glTexture2D的第0层；
• 第二，纹理坐标不是标准化的，意味着纹理坐标实际上对像素寻址，而不是从0.0到1.0的范围覆盖图像的，纹理坐标（5，19）实际上上图像从左起6个像素，以及从上面起20个像素。此外纹理坐标不能重复，并且不支持纹理压缩；

        相对于使用纹理来获得3D模型表面特征，这种方式对于许多OpenGL用来处理和提交图像数据的应用程序来说更加方便，对于纹理矩形的硬件支持也比对通常的2D纹理贴图更简单，并且更快，效率更高。

2、立方体贴图

        立方体贴图上作为一个单独的纹理对象看待的，但是它是由组成立方体六个面的六个正方形的2D数据组成，立方体贴图的应用范围包括3D光线追踪，反射和高精度环境贴图等。

        立方体贴图的增加了6个不同的贴图参数，用以传递到glTexImage2D中进行读取；

 GL_TEXTURE_CUBE_MAP_POSITIVE_X,
 GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z

         这些常量展示了包围贴图物体立方体表面的场景坐标方向，例如，要加载X轴方向的贴图，可以使用；

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, iWidth, iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pImage);

        当我们在立方体贴图上使用Mip贴图时，沿着两个面结合的边缘常常会出现缝隙，OpenGL内部会调整自己的过滤规则；

        在启用GL_TEXTURE_CUBE_MAP_SEAMLESS时帮助消除这些缝隙；

glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);

3、多重纹理

        以前接触的纹理贴图都是将一个单独的纹理加载到纹理对象上，当我们想使用这个纹理时，将他绑定到选定的纹理对象上，然后将片段着色器中的单个统一值设置为0，因为0是我们将要绑定到的纹理单元的索引，现在的OpenGL允许我们将独立的纹理对象绑定到一些可用的纹理单元上，从而提供了将两个或者更多纹理同时应用到几何图形上的能力。

        可以使用下面函数查询支持纹理单元的数量；

GLint iUnits ；
glGetIntegerv(GL_MAX_TEXTURE_UNIT,&iUnits)；

        默认情况下，第一个纹理单元为活动的纹理单元，所有纹理绑定操作都会影响当前活动的纹理单元。可以通过调用以纹理单元标识符为变量的glActiveTexture来改变当前纹理单元，例如要切换到第二个纹理单元并将它绑定到指定的纹理上，可以像下面这样操作；

glActiveTexture(GL_TEXTURE1); 
glBindTexture(GL_TEXTURE_2D,textureID);

         在使用多个纹理进行渲染时候，记住那个纹理单元是当前活动的，这一点非常重要；

4、多重纹理坐标

        有两个函数可以提供纹理坐标，第一个函数是CopyTexCoordData2，它的速度是最快的，因为它会一次复制整个一组纹理坐标。

void GLBatch::CopyTexCoordData2f(M3DVector2f *vTexCoords,GLuint uiTextureLayer);

         第二个函数则是使用较慢的每次指定一个顶点的接口；有两种方式指定一个二维纹理坐标，每次指定一个；

void GLBatch::MultiTexCoord2f(GLuint texture,GLclampf s,GLclampf t);
void GLBatch::MultiTexCoord2fv(GLuint texture,M3DVector2f  vTexCoords);

5、代码实现

Render.CPP

#include <glew/glew.h>                           //GLEW库引入(一定要在GLUT引入之前引入，否则会编译错误),如果要引入其他OpenGL头文件，必须要注意将这个头文件放在前面
 
#include <gltools/GLTools.h>
#include <gltools/GLShaderManager.h>           //着色器管理类
#include <gltools/GLMatrixStack.h>            //矩阵堆栈
#include <gltools/GLFrame.h>                 //矩阵
#include <gltools/GLFrustum.h>              //投影矩阵
#include <gltools/GLBatch.h>               //三角形批次类
#include <gltools/GLGeometryTransform.h>  //几何变换管道
#include <gltools/StopWatch.h>           //时间管理
#include <freeglut/freeglut.h>
 
#include <math.h>                     //数学库  
#include <iostream>
using namespace std;
 
 
//矩阵存储在堆区，而地址是存储在栈区，在大量进行变换的应用的场景中，就需要顶点与大量的变换矩阵进行相乘，这时候就需要大量的构造矩阵，这时候有一个便利的矩阵构造函数可以进行构造矩阵操作矩阵乘法会方便很多，在math3d的这个类被称为GLMatrixsStack。
//使用矩阵堆栈进行矩阵的创建和操作矩阵乘法很方便，但是我们还要方便的管理这些堆栈，就是说我们可以随时方便取到堆栈矩阵的地址，GLGeometryTransform可以设置指针指向我们创建好的堆栈矩阵。
 
 
 
//GTools封装的类 
GLFrame             viewFrame;          //GLFrame是拿来做变化用的。可以用来产生模型视图矩阵。来产生位置的移动 GetCameraMatrix是GLFrame的一个函数，我们通常会用这个来进行设置，我们可以通过此函数来获取一个观察者变换过后的矩阵 视觉坐标系
GLFrustum           viewFrustum;        //创建一个透视投影的矩阵
GLTriangleBatch     sphereBatch;        //GLTriangleBatch类是专门作为三角形的批次容器的，每个顶点都可以有一个表面法线，以进行光照计算和纹理坐标。
GLMatrixStack       modelViewMatrix;    //矩阵堆栈类GLMatrixStack, 这个矩阵堆栈在初始化时候包含了单位矩阵
GLMatrixStack       projectionMatrix;   //矩阵堆栈类GLMatrixStack, 这个矩阵堆栈在初始化时候包含了单位矩阵
GLGeometryTransform transformPipeline;  //矩阵管理器
 
GLShaderManager shaderManager;  //材质管理类 声明着色器对象
 
//球体着色器 使用的贴图与属性ID
GLuint	 diffuseLightShader;	  // 灯光材质ID
GLint    locAmbient;	         //环境光颜色
GLint	 locDiffuse;		// 默认灯光颜色
GLint	 locLight;	       // 灯光位置
GLint    locSpecular;         //高光颜色
GLint	 locMVP;             // 模型视图投影矩阵
GLint	 locMV;		    // 模型视图矩阵
GLint	 locNM;            //法线矩阵
GLint   locTexture;       //着色器里贴图地址
GLuint  texture[2];      //为贴图创建ID
 
//矩形着色器 使用的贴图与属性ID
GLBatch	logoBatch;           //矩形纹理使用矩形片
GLint	rectReplaceShader;   //矩形Shader ID
GLint   locRectMVP;          //矩形Shader参数
GLint	locRectTexture;      //矩形纹理 贴图  
//天空盒着色器 使用的贴图 属性ID
GLint               skyBoxShader;          //天空球的着色器
GLint		    locMVPSkyBox;          //天空球的MVP 矩阵
GLuint              cubeTexture;           //天空球的CubeMap
GLBatch             cubeBatch;             //天空球模型
GLint               locInvertedCamera;     //天空球 转置摄像机矩阵 用来计算立方体贴图的纹理坐标
GLint               LocCubeMap;            //材质属性里天空球 贴图ID 
 
 
// 导入TGA图片 并初始化相关设置
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;
	//设置贴图的过滤和环绕模式
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
 
	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);
	//判断是否生成MinMap贴图
	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;
}
//导入矩形纹理
//与普通导入TGA类似，删除了Mip贴图相关的代码，纹理的过滤器模式只能使用GL_NEAREST或GL_LINEAR//GL_REPEAT和GL_REPEAT_MIRRORED环绕模式纹理不在支持
bool LoadTGATextureRect(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;
	//设置过滤与环绕模式
	glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, wrapMode);
	glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, wrapMode);
 
	glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, minFilter);
	glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, magFilter);
 
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexImage2D(GL_TEXTURE_RECTANGLE, 0, nComponents, nWidth, nHeight, 0,
		eFormat, GL_UNSIGNED_BYTE, pBits);
 
	free(pBits);
 
	return true;
}
 
//立方体贴图 六个面对应的贴图的格式和名字 
const char *szCubeFaces[6] = { "pos_x.tga", "neg_x.tga", "pos_y.tga", "neg_y.tga", "pos_z.tga", "neg_z.tga" };
 
GLenum  cube[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X,
					 GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
					 GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
					 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
					 GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
					 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };
 
bool LoadCubeMapTexture()
{
	//加载立方体贴图
	GLbyte *pBytes;
	GLint iWidth, iHeight, iComponents;
	GLenum eFormat;
	int i;
 
 
	// 设置贴图的过滤模式 与环绕模式
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
 
	// 导入图片 六个方向
	for (i = 0; i < 6; i++)
	{
		// 导入
		pBytes = gltReadTGABits(szCubeFaces[i], &iWidth, &iHeight, &iComponents, &eFormat);
		//加载
		glTexImage2D(cube[i], 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);
		free(pBytes);
	}
	glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
	
	return true;
}
 
void ChangeSize(int w, int h)
{
	// 高度不为0
	if (h == 0)
		h = 1;
 
	// 设置渲染窗口的大小为窗口大小
	glViewport(0, 0, w, h);
	//设置投影矩阵  FOV 35  近截面1.0  远截面距离100
	viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 100.0f);
 
	//创建投影矩阵，并将它载入到投影矩阵堆栈中
	projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
	//设置管线以使用两个矩阵堆栈   初始化transformPipeline 通过将它的内部指针设置为指向模型视图矩阵堆栈和投影矩阵堆栈实例完成这项任务
	transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
}
//设置矩形纹理所使用的模型参数
void SetRectRC()
{
	//设置矩形纹理 所在的位置及大小
	int x = 700;
	int y = 155;
	int width = 300;
	int height = 155;
	logoBatch.Begin(GL_TRIANGLE_FAN, 4, 1);
 
	// 左上角 
	//函数 void MultiTexCoord2f(GLuint texture, GLclampf s, GLclampf t); texcoord  0
	logoBatch.MultiTexCoord2f(0, 0.0f, height);
	logoBatch.Vertex3f(x, y, 0.0);
 
	// 左下角
	logoBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
	logoBatch.Vertex3f(x, y - height, 0.0f);
// 右下角
	logoBatch.MultiTexCoord2f(0, width, 0.0f);
	logoBatch.Vertex3f(x + width, y - height, 0.0f);
 
	// 右上角
	logoBatch.MultiTexCoord2f(0, width, height);
	logoBatch.Vertex3f(x + width, y, 0.0f);
	logoBatch.End();
}
//设置渲染环境  执行一次
void SetupRC()
{
	
	//初始化 GLTOOLs 里的储存着色器  初始化着色器对象
	shaderManager.InitializeStockShaders();
	viewFrame.MoveForward(4.0f);        //向后移动模型 模拟摄像机   
 
	 //创建一个球体将顶点存在sphereBatch中
	gltMakeSphere(sphereBatch, 1.0f, 26, 13);    
 
	//指定球体着色器路径，以及顶点属性个数和ID
	diffuseLightShader = shaderManager.LoadShaderPairWithAttributes("SimpleShaderTest01.vs", "SimpleShaderTest01.fs", 3, GLT_ATTRIBUTE_VERTEX, "vVertex",
		GLT_ATTRIBUTE_NORMAL, "vNormal", GLT_ATTRIBUTE_TEXTURE0, "vTexture0");
 
	//获取材质里的变量ID 地址
	locAmbient = glGetUniformLocation(diffuseLightShader, "ambientColor");
	locDiffuse = glGetUniformLocation(diffuseLightShader, "diffuseColor");
	locSpecular = glGetUniformLocation(diffuseLightShader, "specularColor");
	locLight = glGetUniformLocation(diffuseLightShader, "vLightPosition");
	locMVP = glGetUniformLocation(diffuseLightShader, "mvpMatrix");
	locMV = glGetUniformLocation(diffuseLightShader, "mvMatrix");
	locNM = glGetUniformLocation(diffuseLightShader, "normalMatrix");
	locTexture = glGetUniformLocation(diffuseLightShader, "colorMap");
	LocCubeMap = glGetUniformLocation(diffuseLightShader, "cubeMap");
	locInvertedCamera = glGetUniformLocation(diffuseLightShader, "mInverseCamera");
 
	glGenTextures(1, texture);
	glActiveTexture(GL_TEXTURE0);//激活纹理单元0
	glBindTexture(GL_TEXTURE_2D, texture[0]);
	LoadTGATexture("CoolTexture.tga", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE);
 
	glGenTextures(1, &cubeTexture);
	glActiveTexture(GL_TEXTURE1);//激活纹理单元1
	glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);
	LoadCubeMapTexture();
//矩形纹理
	SetRectRC();
	//矩形Shader
	rectReplaceShader = gltLoadShaderPairWithAttributes("ShaderRectTestVS.vs", "ShaderRectTestFS.fs",
		2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "vTexCoord");
	//矩形Shader 着色器变量
	locRectMVP = glGetUniformLocation(rectReplaceShader, "mvpMatrix");
	locRectTexture = glGetUniformLocation(rectReplaceShader, "rectangleImage");
	//导入矩形贴图
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_RECTANGLE, texture[1]);
	LoadTGATextureRect("OpenGL-Logo.tga", GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE);
 
	//天空球
	glGenTextures(1, &cubeTexture);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);
	LoadCubeMapTexture();
	gltMakeCube(cubeBatch, 20.0f);
	//天空盒着色器
	skyBoxShader = gltLoadShaderPairWithAttributes("ShaderSkyBoxVS.vs", "ShaderSkyBoxFS.fs", 2,
		GLT_ATTRIBUTE_VERTEX, "vVertex",
		GLT_ATTRIBUTE_NORMAL, "vNormal");
	//设置天空球着色器变量
	locMVPSkyBox = glGetUniformLocation(skyBoxShader, "mvpMatrix");
 
	
}
 
//清除材质信息
void ShutdownRC()
{
	glDeleteProgram(diffuseLightShader);
	glDeleteTextures(1, texture);
}
//渲染场景 循环执行
void RenderScene(void)
{
	static CStopWatch rotTimer;
	//设置背景颜色 缓冲区
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
	//声明矩阵变量 用来储存摄像机矩阵与 转置矩阵
       //使用表面法线和指向顶点的向量在着色器中创建一个视觉坐标系中的反射向量，另外为了获得一个真实的反射，还要考虑摄像机方向，从GLFrame类中提取出照相机的旋转矩阵并进行转置，然将其作为 统一值，与另一个变换矩阵（用来对前述的反射向量进行旋转，这个反射向量实际上就是立方体贴图的纹理坐标）一起提供给着色器。
      //如果不对纹理坐标进行旋转，那么当摄像机在场景中移动时，立方体贴图将不能正确地反射围绕它的天空盒。
	M3DMatrix44f mCameraRotOnly;
	M3DMatrix44f mInverseCamera;
//获取 并赋值摄像机矩阵与 转置矩阵
	viewFrame.GetCameraMatrix(mCameraRotOnly, true);
	m3dInvertMatrix44(mInverseCamera, mCameraRotOnly);
 
 
	//渲染 球体
	modelViewMatrix.PushMatrix(viewFrame);
	modelViewMatrix.Rotate(rotTimer.GetElapsedSeconds() * 10.0f, 0.0f, 1.0f, 0.0f);
	//灯光参数
	GLfloat vEyeLight[] = { -100.0f, 100.0f, 100.0f };
	GLfloat vAmbientColor[] = { 0.1f, 0.1f, 0.1f, 1.0f };
	GLfloat vDiffuseColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	GLfloat vSpecularColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 
	//渲染球体 为使用的材质变量 赋值
	glBindTexture(GL_TEXTURE_2D, texture[0]);
	glUseProgram(diffuseLightShader);
	glUniform4fv(locAmbient, 1, vAmbientColor);
	glUniform4fv(locDiffuse, 1, vDiffuseColor);
	glUniform4fv(locSpecular, 1, vSpecularColor);
	glUniform3fv(locLight, 1, vEyeLight);
	glUniformMatrix4fv(locMVP, 1, GL_FALSE, transformPipeline.GetModelViewProjectionMatrix());
	glUniformMatrix4fv(locMV, 1, GL_FALSE, transformPipeline.GetModelViewMatrix());
	glUniformMatrix3fv(locNM, 1, GL_FALSE, transformPipeline.GetNormalMatrix());
	glUniformMatrix4fv(locInvertedCamera, 1, GL_FALSE, mInverseCamera);
	glUniform1i(locTexture, 0);
	glUniform1i(LocCubeMap, 1);
	glEnable(GL_DEPTH_TEST);    //开启深度测试
	glEnable(GL_CULL_FACE);     //开启背面剔除
	sphereBatch.Draw();         //渲染球体 
	modelViewMatrix.PopMatrix();
 
	//渲染天空球 反射  为使用的材质变量 赋值
	modelViewMatrix.PushMatrix();
	modelViewMatrix.MultMatrix(mCameraRotOnly);
	glUseProgram(skyBoxShader);
	glUniformMatrix4fv(locMVPSkyBox, 1, GL_FALSE, transformPipeline.GetModelViewProjectionMatrix());
	glUniform1i(LocCubeMap, 0);
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);
	cubeBatch.Draw();  //渲染天空盒
	modelViewMatrix.PopMatrix();
//渲染矩形纹理
	//设置矩形Shader所使用的的 MVP
	//在屏幕空间绘制时，普遍的做法上创建一个与屏幕大小相匹配的正投影矩阵，选择让坐标系与屏幕上的纹理匹配，将原点设置在左下角
	M3DMatrix44f mScreenSpace;
	m3dMakeOrthographicMatrix(mScreenSpace, 0.0f, 1024, 0.0f, 720, -1.0f, 1.0f);
	//开启半透明混合，及设置混合模式
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  //设置混合模式
	glDisable(GL_DEPTH_TEST);//关闭深度测试
	//启用，并设置说着色器参数
	glUseProgram(rectReplaceShader);
	glUniform1i(locRectTexture, 0);
	glUniformMatrix4fv(locRectMVP, 1, GL_FALSE, mScreenSpace);
	glBindTexture(GL_TEXTURE_RECTANGLE, texture[1]);
	logoBatch.Draw(); //渲染矩形纹理
	glDisable(GL_BLEND);  //关闭混合
	glEnable(GL_DEPTH_TEST); //开启深度测试
 
	//双缓冲
	glutSwapBuffers();
	glutPostRedisplay();
}
 
int main(int argc, char*argv[])
{
	gltSetWorkingDirectory(argv[0]);
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
	glutInitWindowSize(1024, 720);   //窗口大小
	glutCreateWindow("Render");      //渲染窗口名称 
	glutReshapeFunc(ChangeSize);     //改变窗口尺寸时执行适配窗口函数
	glutDisplayFunc(RenderScene);   //渲染
 
	//检测初始化过程是否有问题
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		cout << "Error: '%s'\n" << glewGetErrorString(err) << endl;
		return 1;
	}
 
	//初始化渲染环境 预加载纹理 建立几何图形 渲染器等
	SetupRC();  
	glutMainLoop();
	ShutdownRC();
	return 0;
}

SimpleShaderTest01.vs

#version 330   //声明版本
 
// 输入顶点位置 和 法线 属性
in vec4 vVertex;
in vec3 vNormal;
in vec4 vTexture0;
 
// 声明 着色器变量
uniform vec3 vLightPosition; //灯光位置
uniform mat4 mvpMatrix; //模型视图透视矩阵
uniform mat4 mvMatrix; //模型视图矩阵    
uniform mat3 normalMatrix; //法线矩阵 
uniform mat4 mInverseCamera;
 
// 输出灯光方向 与法线向量
smooth out vec3 vVaryingLightDir;
smooth out vec3 vVaryingNormal;
smooth out vec2 vTexCoords;
smooth out vec3 vVaryingTexCoord;
 
void main(void)
{
    // 获取表面法线的视觉空间下坐标
    vVaryingNormal = normalMatrix * vNormal;
 
    // 获取顶点位置在视觉空间下的坐标
    vec4 vPosition4 = mvMatrix * vVertex;
    vec3 vPosition3 = vPosition4.xyz / vPosition4.w;
 
    // 获取灯光方向
    vVaryingLightDir = normalize(vLightPosition - vPosition3);
 
    vTexCoords = vTexture0.st;
    
    //获取反射向量 计算CubeMap坐标
    vec4 vCoords = vec4(reflect(normalize(vPosition3), vVaryingNormal), 1.0);
    vCoords = mInverseCamera * vCoords;
    vVaryingTexCoord.xyz = normalize(vCoords.xyz);
    // 坐标转换到裁剪坐标系下
    gl_Position = mvpMatrix * vVertex;
}

SimpleShaderTest01.fs

#version 330      //声明版本
 
out vec4 vFragColor;
 
uniform vec4 ambientColor; //环境光颜色
uniform vec4 diffuseColor; //默认灯光颜色 
uniform vec4 specularColor; //高光颜色
uniform sampler2D colorMap;
uniform samplerCube cubeMap;
 
smooth in vec3 vVaryingNormal; //输入平滑过后的法线
smooth in vec3 vVaryingLightDir; //输入平滑过后的灯光方向
smooth in vec2 vTexCoords;
smooth in vec3 vVaryingTexCoord;  //CubeMap 纹理坐标
 
void main(void)
{
 //漫反射计算
    float diff = max(0.0, dot(normalize(vVaryingNormal), normalize(vVaryingLightDir)));
    vFragColor = diff * diffuseColor;
 //环境光
    vFragColor += ambientColor;
 
    vFragColor *= texture(colorMap, vTexCoords);
 
 //反射光线计算  高光计算
    vec3 vReflection = normalize(reflect(-normalize(vVaryingLightDir), normalize(vVaryingNormal)));
    float spec = max(0.0, dot(normalize(vVaryingNormal), vReflection));
    if (diff != 0)
    {
        float fSpec = pow(spec, 128.0);
        vFragColor.rgb += vec3(fSpec, fSpec, fSpec);
        
    }
    vec4 cubemapColor = texture(cubeMap, vVaryingTexCoord.stp);
    vFragColor += cubemapColor;
    
}

ShaderRectTestVS.vs

#version 330
 
// 导入顶点于 纹理坐标
in vec4 vVertex;
in vec2 vTexCoord;
 
uniform mat4 mvpMatrix;
 
// 输出纹理坐标
smooth out vec2 vVaryingTexCoord;
 
 
void main(void)
{
    // 纹理坐标
    vVaryingTexCoord = vTexCoord;
    
    // 裁剪坐标系下坐标
    gl_Position = mvpMatrix * vVertex;
}

ShaderRectTestFS.fs

#version 330
 
out vec4 vFragColor;
 
uniform sampler2DRect rectangleImage;
 
smooth in vec2 vVaryingTexCoord;
 
void main(void)
{
    vFragColor = texture(rectangleImage, vVaryingTexCoord);
}

ShaderSkyBoxVS.vs

#version 330
 
// 输入每个顶点 只输入位置
in vec4 vVertex;
 
uniform mat4 mvpMatrix; // 变换矩阵
 
// 片段程序的纹理坐标
out vec3 vVaryingTexCoord;
 
 
void main(void)
{
    // 传递纹理坐标
    vVaryingTexCoord = normalize(vVertex.xyz);
 
    // 对顶点进行变换 
    gl_Position = mvpMatrix * vVertex;
}

ShaderSkyBoxFS.fs

#version 330
 
out vec4 vFragColor;
 
uniform samplerCube cubeMap;
 
in vec3 vVaryingTexCoord;
 
void main(void)
{
    vFragColor = texture(cubeMap, vVaryingTexCoord);
}

效果预览：