OpenGL纹理

纹理简单说即图片的不同叫法而已，就是一种应用场景中的三角形图像数据。

• 原始的图像数据： 图像的存储空间 = 图像的高度 * 图像的宽度 * 每个像素的字节数
• 纹理对象
  纹理对象允许我们一次加载一个以上的纹理状态，和在他们之间快速切换。
  纹理状态是由当前绑定的纹理对象维护的。而纹理对象时一个无符号整数标识的

//分配纹理对象 参数1：纹理对象的数量 参数2：指针（指向一个无符号整形数组，由纹理对象标识符填充）
void glGenTextures(GLsizei n,GLuint * textTures);
//绑定纹理状态
//参数target:GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
//参数texture:需要绑定的纹理对象
void glBindTexture(GLenum target,GLunit texture);

//删除绑定纹理对象
//纹理对象 以及 纹理对象指针（指针指向一个无符号整形数组，由纹理对象标识符填充）。
void glDeleteTextures(GLsizei n,GLuint *textures);

//测试纹理对象是否有效
//如果texture是一个已经分配空间的纹理对象，那么这个函数会返回GL_TRUE,否则会返回GL_FALSE。
GLboolean glIsTexture(GLuint texture);

 /**
         加载tga文件
         参数1：纹理文件名称
         参数2：文件宽度变量地址
         3：文件高度变量地址
         4：文件组件变量地址
         5：文件格式变量地址
         返回值：pBytes 指向图像数据的指针
         */
GLbyte *gltReadTGABits(const char *szFileName, GLint *iWidth, GLint *iHeight, GLint *iComponents, GLenum *eFormat);

• 设置纹理的参数

/* 
glTexParameterf(GLenum target,GLenum pname,GLFloat param);
glTexParameteri(GLenum target,GLenum pname,GLint param);
glTexParameterfv(GLenum target,GLenum pname,GLFloat *param);
glTexParameteriv(GLenum target,GLenum pname,GLint *param);

参数1:target,指定这些参数将要应用在那个纹理模式上，比如GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D。
参数2:pname,指定需要设置那个纹理参数
参数3:param,设定特定的纹理参数的值
*/

 //加载纹理、设置过滤器和包装模式
        //GL_TEXTURE_MAG_FILTER(放大过滤器，GL_NEAREST(最邻近过滤))
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        //GL_TEXTURE_MIN_FILTER(缩小过滤器),GL_NEAREST(最邻近过滤)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        
        /*GL_TEXTURE_WRAP_S (s轴环绕) GL_CLAMP_TO_DEGE(环绕模式强制对范围之外的纹理坐标沿着
        合法的纹理单元的最后一行 或一列进行采样
        */
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        //t轴采样
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

• 加载纹理
  void glTexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,void *data);

void glTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,void * data);

void glTexImage3D(GLenum target,GLint level,GLint internalformat,GLSizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,void *data);

//target:GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D 。
//Level :指定所加载的mip贴图层次。一般我们都把这个参数设置为0。
//internalformat:每个纹理单元中存储多少颜色成分。
//width、height、depth 参数:指加载纹理的宽度、高度、深度。
//border参数:允许为纹理贴图指定一个边界宽度。
//format参数:gltReadTGABits函数中,通过 eFormat 参数返回图片的颜色格式
//type参数:OpenGL 数据存储方式,一般使用 GL_UNSIGNED_BYTE
//data参数:图片数据指针*

 /*
         载入纹理
         参数1：纹理维度
         参数2：mip贴图层次
         参数3：纹理单元存储的颜色成分（从读取像素图获得）
         参数4：加载纹理宽
         参数5：加载纹理高
         参数6：加载纹理深度
         参数7：文件格式
         参数8：像素数据的数据类型（GL_UNSIGNED_BYTE,每个颜色分量都是一个8位无符号整数）
         参数9：指向纹理图像数据的指针
         */
        glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);

• 设置环绕模式

 case 0: //缩小过滤 最邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                break;
            case 1: //缩小过滤 线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINE);
                break;
            case 2: //缩小过滤 选择最邻近Mip层 并执行最邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
                break;
            case 3: //在Mip层之间执行线性插补，并执行最近邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
                break;
            case 4: //缩小过滤 选择最近mip层 并进行线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                break;
            case 5://缩小过滤 在mip层之间执行线性插补，并执行线性过滤，又称为三线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                break;
            case 6:
                //设置各向异性过滤
                GLfloat fLargest;
                //获取各向异性过滤的最大数量
                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);
                //设置纹理参数（各向异性采样）
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);
                break;
            case 7:
                //设置各向同性过滤，数量1.0 表示（各向同性采样）
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
                break;

• 整合代码

//
//  main.m
//  Created by apple on 2019/11/25.
//  Copyright © 2019年 apple. All rights reserved.
//

#include "GLTools.h"
#include "GLShaderManager.h"
#include "GLFrustum.h"
#include "GLBatch.h"
#include "GLFrame.h"
#include "GLMatrixStack.h"
#include "GLGeometryTransform.h"

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

GLFrustum                viewFrustum;
GLMatrixStack            projectionMatrix;
GLGeometryTransform      transformPipeline;
GLMatrixStack            modelViewMatrix;
GLFrame                  objectFrame;
GLFrame                  cameraFrame;
GLShaderManager          shaderManager;

//4个批次容器类
GLBatch                     floorBatch;     //地面
GLBatch                     ceilingBatch;   //天花板
GLBatch                     leftWallBatch;  //左墙面
GLBatch                     rightWallBatch; //右墙面

//深度初始值，-65。
GLfloat             viewZ = -65.0f;

// 纹理标志符号
#define TEXTURE_BRICK       0 //墙面
#define TEXTURE_FLOOR       1 //地板
#define TEXTURE_CEILING     2 //纹理天花板
#define TEXTURE_COUNT       3 //纹理个数

GLuint texures[TEXTURE_COUNT];//纹理标记数组
//文件tag名字数组
const char *szTextureFiles[TEXTURE_COUNT] = {"brick.tga", "floor.tga", "ceiling.tga"};

//在这个函数里能够在渲染环境中进行任何需要的初始化，它这里的设置并初始化纹理对象
void SetupRC(){
    //黑色背景
    glClearColor(0.0f,0.0f,0.0f,1.0f);
    //初始化shaderManager
    shaderManager.InitializeStockShaders();
    
    GLbyte *pBytes;
    GLint  iWidth ,iHeight, iComponents;
    GLenum eFormat;
    GLint  iLoop;
    
    //生成纹理标记
    /**
     分配纹理对象 glGenTextures;
     参数1：纹理对象的数量
     参数2：纹理对象标识数组
     */
    glGenTextures(TEXTURE_COUNT, texures);
    //循环设置纹理数组的纹理参数
    for (iLoop = 0; iLoop < TEXTURE_COUNT; iLoop ++) {
        /**
         绑定纹理对象 glBindTexture
         参数1：纹理模式 GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D
         参数2：需要绑定的纹理对象
         */
        glBindTexture(GL_TEXTURE_2D, texures[iLoop]);
        /**
         加载tga文件
         参数1：纹理文件名称
         参数2：文件宽度变量地址
         3：文件高度变量地址
         4：文件组件变量地址
         5：文件格式变量地址
         返回值：pBytes 指向图像数据的指针
         */
        
        pBytes = gltReadTGABits(szTextureFiles[iLoop], &iWidth, &iHeight, &iComponents, &eFormat);
        //加载纹理、设置过滤器和包装模式
        //GL_TEXTURE_MAG_FILTER(放大过滤器，GL_NEAREST(最邻近过滤))
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        //GL_TEXTURE_MIN_FILTER(缩小过滤器),GL_NEAREST(最邻近过滤)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        
        /*GL_TEXTURE_WRAP_S (s轴环绕) GL_CLAMP_TO_DEGE(环绕模式强制对范围之外的纹理坐标沿着
        合法的纹理单元的最后一行 或一列进行采样
        */
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        //t轴采样
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        /*
         载入纹理
         参数1：纹理维度
         参数2：mip贴图层次
         参数3：纹理单元存储的颜色成分（从读取像素图获得）
         参数4：加载纹理宽
         参数5：加载纹理高
         参数6：加载纹理深度
         参数7：文件格式
         参数8：像素数据的数据类型（GL_UNSIGNED_BYTE,每个颜色分量都是一个8位无符号整数）
         参数9：指向纹理图像数据的指针
         */
        glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);
        /*
         为纹理对象生成一组完成的mipmap glGenerateMipmap
         参数1：纹理维度 GL_TEXTURE_1D GL_TEXUTRE_2D GL_TEXTURE_2D
         */
        glGenerateMipmap(GL_TEXTURE_2D);
        //释放原始纹理数据 不在需要纹理原始数据了
        free(pBytes);
    }
    //设置几何图形顶点、纹理坐标（上、下、左、右）
    GLfloat z;
    /**
     GLTools库中的容器类 GLBatch
     void GLBatch::Begin(GLenum primitive,GLuint nVerts,GLuint nTextureUnits = 0);
     参数1：图元枚举值
     参数2：顶点数
     参数3：1组或者2组纹理坐标
     */
    //三角形带
    floorBatch.Begin(GL_TRIANGLE_STRIP, 28,1);
    //隧道的深度
    for (z = 60.0f; z >= 0.0f; z -= 10.0f) {
//        设置纹理坐标 2.设置纹理坐标
//        void MultiTexCoord2f(GLunit texture,GLclampf s,GLclamp t)
//        参数1：texture 纹理层次，对于使用存储着色器来进行渲染 设置为0
//        参数2：s:对一个顶点坐标中的x坐标
//        参数3：t:对应顶点坐标中的y
//        （s,t,r,q对应顶点坐标中的 x,y,z,w）
        floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
        floorBatch.Vertex3f(-10.0f, -10.0f, z);
        
        
        floorBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
        floorBatch.Vertex3f(10.0f, -10.0f, z);
        
        floorBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
        floorBatch.Vertex3f(-10.0f,-10.0f, z - 10.0f);
        
        floorBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
        floorBatch.Vertex3f(10.0f, -10.0f,z - 10);
    
    }
    floorBatch.End();
    
    //顶部
    ceilingBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
    for(z = 60.0f; z >= 0.0f; z -=10.0f)
    {
        ceilingBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
        ceilingBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);
        
        ceilingBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
        ceilingBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);
        
        ceilingBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
        ceilingBatch.Vertex3f(-10.0f, 10.0f, z);
        
        ceilingBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
        ceilingBatch.Vertex3f(10.0f, 10.0f, z);
    }
    ceilingBatch.End();
    
    //左墙
    leftWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
    for(z = 60.0f; z >= 0.0f; z -=10.0f)
    {
        leftWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
        leftWallBatch.Vertex3f(-10.0f, -10.0f, z);
        
        leftWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
        leftWallBatch.Vertex3f(-10.0f, 10.0f, z);
        
        leftWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
        leftWallBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f);
        
        leftWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
        leftWallBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);
    }
    leftWallBatch.End();
    
    //右墙
    rightWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
    for(z = 60.0f; z >= 0.0f; z -=10.0f)
    {
        rightWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
        rightWallBatch.Vertex3f(10.0f, -10.0f, z);
        
        rightWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
        rightWallBatch.Vertex3f(10.0f, 10.0f, z);
        
        rightWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
        rightWallBatch.Vertex3f(10.0f, -10.0f, z - 10.0f);
        
        rightWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
        rightWallBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);
    }
    rightWallBatch.End();
}
void ShutdownRC(){
    //删除纹理
    glDeleteTextures(TEXTURE_COUNT, texures);
}
void SpecialKeys(int key,int x,int y){
    if (key == GLUT_KEY_UP) { //前进
        //移动的深度值 Z
        viewZ += 0.5f;
    }
    
    if (key == GLUT_KEY_DOWN) {
        viewZ -= 0.5f;
    }
    //更新窗口，即可回调RenderScene函数里
    glutPostRedisplay();
    
}
void ChangeSize(int w,int h){
    //设置视口
    glViewport(0, 0, w, h);
    //创建投影矩阵
    viewFrustum.SetPerspective(35.0f, float(w)/float(h), 1.0f, 500.0f);
    //获取viewFrustum投影矩阵，并将其加载到投影矩阵堆栈上
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    //设置变化管道 以使用两个矩阵堆栈（变换矩阵：modelViewMatrix ,投影矩阵：projectMatrix）
    //初始化GLGeometryTransform 实例 transformPipline
    /*
     通过将它的内部指针设置为模型视图矩阵堆栈 和投影矩阵堆栈 实例 来完成初始化
     当然这个操作也可以在setupRC 函数中完成，但是在窗口大小改变时 或者窗口设置他们并没有坏处，而且这样可以一次性完成矩阵和管线的设置
     */
    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
    
}
//调用绘制场景
void RenderScene(void){
    glClear(GL_COLOR_BUFFER_BIT);
    
    //模型视图压栈
    modelViewMatrix.PushMatrix();
    //z轴平移viewZ 距离
    modelViewMatrix.Translate(0.0f, 0.0f, viewZ);
    // 纹理替换矩阵着色器
    /*
     参数1：GLT_SHADER_TEXTURE_REPLACE （着色器标签）
     参数2：模型视图投影矩阵
     参数3：纹理层
     */
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,
                                 transformPipeline.GetModelViewProjectionMatrix(),
                                 0);
    
    /*
     绑定纹理
     参数1:纹理模式，GL_TEXTURE_1D GL_TEXTURE_2D GL_TEXTURE_3D
     参数2：需要绑定的纹理
     */
    glBindTexture(GL_TEXTURE_2D, texures[TEXTURE_FLOOR]);
    floorBatch.Draw();
    
    
    glBindTexture(GL_TEXTURE_2D, texures[TEXTURE_CEILING]);
    ceilingBatch.Draw();
    
    glBindTexture(GL_TEXTURE_2D, texures[TEXTURE_BRICK]);
    leftWallBatch.Draw();
    rightWallBatch.Draw();
    
    //5.pop
    modelViewMatrix.PopMatrix();
    
    //交换缓存区
    glutSwapBuffers();
}
void ProcessMenu(int value){
    GLint iLoop;
    for (iLoop = 0 ; iLoop < TEXTURE_COUNT ; iLoop ++) {
        /*
         绑定纹理 glBindTexture
         参数1：GL_TEXTURE_2D
         参数2：需要绑定的纹理对象
         */
        glBindTexture(GL_TEXTURE_2D, texures[iLoop]);
        switch (value) {
            case 0: //缩小过滤 最邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                break;
            case 1: //缩小过滤 线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINE);
                break;
            case 2: //缩小过滤 选择最邻近Mip层 并执行最邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
                break;
            case 3: //在Mip层之间执行线性插补，并执行最近邻近过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
                break;
            case 4: //缩小过滤 选择最近mip层 并进行线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                break;
            case 5://缩小过滤 在mip层之间执行线性插补，并执行线性过滤，又称为三线性过滤
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                break;
            case 6:
                //设置各向异性过滤
                GLfloat fLargest;
                //获取各向异性过滤的最大数量
                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);
                //设置纹理参数（各向异性采样）
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);
                break;
            case 7:
                //设置各向同性过滤，数量1.0 表示（各向同性采样）
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
                break;
            default:
                break;
        }
    }
    //触发重画
    glutPostRedisplay();
}

int main(int argc, char * argv[]) {
    gltSetWorkingDirectory(argv[0]);
    //标准初始化
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Pyramid");
    glutReshapeFunc(ChangeSize);
    glutSpecialFunc(SpecialKeys);
    glutDisplayFunc(RenderScene);
    
    //添加菜单入口
    glutCreateMenu(ProcessMenu);
    glutAddMenuEntry("GL_NEAREST",0);
    glutAddMenuEntry("GL_LINEAR",1);
    glutAddMenuEntry("GL_NEAREST_MIPMAP_NEAREST",2);
    glutAddMenuEntry("GL_NEAREST_MIPMAP_LINEAR", 3);
    glutAddMenuEntry("GL_LINEAR_MIPMAP_NEAREST", 4);
    glutAddMenuEntry("GL_LINEAR_MIPMAP_LINEAR", 5);
    glutAddMenuEntry("Anisotropic Filter", 6);
    glutAddMenuEntry("Anisotropic Off", 7);

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

• 锥体效果 金字塔纹理效果

//
//  main.cpp
//  Created by apple on 2019/11/19.
//

#include <stdio.h>
#include "GLTools.h"
#include "GLShaderManager.h"
#include "GLFrustum.h"
#include "GLBatch.h"
#include "GLFrame.h"
#include "GLMatrixStack.h"
#include "GLGeometryTransform.h"

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

GLFrustum                viewFrustum;
GLMatrixStack            projectionMatrix;
GLGeometryTransform      transformPipeline;
GLMatrixStack            modelViewMatrix;
GLFrame                  objectFrame;
GLFrame                  cameraFrame;
GLShaderManager          shaderManager;


//纹理变量，一般使用无符号整型
GLuint              textureID;
GLBatch             pyramidBatch;
//绘制金字塔
void MakePyramid(GLBatch& pyramidBatch)
{
    /*
     通过pyramidBatch组件三角形批次
     参数1：类型
     参数2：顶点数
     参数3：这个批次中将会应用1个纹理
     注意：如果不写这个参数，默认为0
     */
    pyramidBatch.Begin(GL_TRIANGLES, 18,1);
    /**
     前情导入
     1.设置法线
     void Normal3f(GLfloat x, GLfloat y,GLfloat z);
     Normal3f:添加一个表面法线（法线坐标 与 Vertex顶点坐标中的Y轴一致)
     表面法线是有方向的向量，代表表面或者顶点面对的方向（相反的方向）在多数的光照模式下是必须使用。
     
     pyramidBatch.Normal3f(X,Y,Z);
     
     2.设置纹理坐标
     void MultiTexCoord2f(GLunit texture,GLclampf s,GLclamp t)
     参数1：texture 纹理层次，对于使用存储着色器来进行渲染 设置为0
     参数2：s:对一个顶点坐标中的x坐标
     参数3：t:对应顶点坐标中的y
     （s,t,r,q对应顶点坐标中的 x,y,z,w）
     
     pyramidBatch.MultiTexCoord2f(0,s,t);
    
     3.void Vertex3f(GLfloat x,GLfloat y,GLfloat z);
     void Vertex3fv(M3DVector3f vVertex);
     向三角形批次类添加顶点数据(x,y,z)
     pyramidBatch.Vertex3f(-1.0f,-1f,-1.0f);
     
     4.获取从三点找到一个法线坐标（三点确定一个面)
     void m3dFindNormal(result,point1,point2,point3);
     参数1：结果
     参数2~4：3个顶点数据
     */
    
    
    //塔顶
    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;
    
    //金字塔底部
    //底部的四边形 = 三角形X + 三角形Y
    //三角形X = (vBackLeft,vBackRight,vFrontRight)
    
    //1.找到三角形X 法线
//    m3dFindNormal(n, vBackLeft, vBackRight, vFrontRight);
    
    //vBackLeft
//    pyramidBatch.Normal3fv(n);//设置法线
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);//设置纹理坐标
    pyramidBatch.Vertex3fv(vBackLeft);//设置顶点数据
    
    //vBackRight
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
    //vFrontRight
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
    
    //三角形Y =(vFrontLeft,vBackLeft,vFrontRight)
    
    //1.找到三角形X 法线
//    m3dFindNormal(n, vFrontLeft, vBackLeft, vFrontRight);
    
    //vFrontLeft
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);
    
    //vBackLeft
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    //vFrontRight
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
    
    // 金字塔前面
    //三角形：（Apex，vFrontLeft，vFrontRight）
//    m3dFindNormal(n, vApex, vFrontLeft, vFrontRight);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
    //金字塔左边
    //三角形：（vApex, vBackLeft, vFrontLeft）
//    m3dFindNormal(n, vApex, vBackLeft, vFrontLeft);
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);
    
    //金字塔右边
    //三角形：（vApex, vFrontRight, vBackRight）
//    m3dFindNormal(n, vApex, vFrontRight, vBackRight);
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
    //金字塔后边
    //三角形：（vApex, vBackRight, vBackLeft）
//    m3dFindNormal(n, vApex, vBackRight, vBackLeft);
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
//    pyramidBatch.Normal3fv(n);
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    //结束批次设置
    pyramidBatch.End();
}
// 将TGA文件加载为2D纹理。
bool LoadTGATexture(const char *szFileName, GLenum minFilter, GLenum magFilter, GLenum wrapMode)
{
    GLbyte *pBits;
    int nWidth,nHeight,nComponents;
    GLenum eFormat;
    /*
     1.读取纹理，读取像素
     参数1：纹理文件名称
     参数2：文件宽度地址
     参数3：文件高度地址
     参数4：文件组件地址
     参数5：文件格式地址
     返回值：pBits，指向图像数据的指针
     */
    pBits = gltReadTGABits(szFileName, &nWidth, &nHeight, &nComponents, &eFormat);
    if (pBits == NULL) {
        return false;
    }
    //设置纹理参数
    /*
     参数1：纹理维度
     参数2：为S/T坐标设置模式
     参数3：wrapMode ，环绕模式
     */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
    
    /*
     参数1：纹理维度
     参数2：线性过滤
     参数3：wrapMode,环绕模式
     */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
    
    /*
     载入纹理
     参数1：纹理维度
     参数2：mip贴图层次
     参数3：纹理单元存储的颜色成分（从读取像素图获得）
     参数4：加载纹理宽
     参数5：加载纹理高
     参数6：加载纹理深度
     参数7：文件格式
     参数8：像素数据的数据类型（GL_UNSIGNED_BYTE,每个颜色分量都是一个8位无符号整数）
     参数9：指向纹理图像数据的指针
     */
    glTexImage2D(GL_TEXTURE_2D, 0, nComponents, nWidth, nHeight, 0,
                 eFormat, GL_UNSIGNED_BYTE, pBits);//像素的数据格式
    
    //使用完毕释放pBits
    free(pBits);
    
    //只有minFilter 等于以下四种模式，才可以生成Mip贴图
    //GL_NEAREST_MIPMAP_NEAREST 具有非常好的性能，并且闪烁现象非常弱
    //GL_LINEAR_MIPMAP_NEAREST 常常用于对游戏进行加速，它使用了高质量的线性过滤器
    //GL_LINEAR_MIPMAP_LINEAR 和 GL_MEAREST_MIPMAP_LINEAR 过滤器在Mip层之间执行了一些额外的插值，以消除他们j之间的l过滤痕迹
    //GL_LINEAR_MIPMAP_LINEAR 三线性Mip贴图，纹理过滤的黄金准侧，具有最高精度
    if (minFilter == GL_LINEAR_MIPMAP_LINEAR||
        minFilter == GL_LINEAR_MIPMAP_NEAREST ||
        minFilter == GL_NEAREST_MIPMAP_LINEAR ||
        minFilter == GL_NEAREST_MIPMAP_NEAREST)
    //加载Mip，纹理生成所有的mip层
    //参数：GL_TEXTURE_1D GL_TEXTURE_2D  GL_TEXTURE_3D
    glGenerateMipmap(GL_TEXTURE_2D);
    
    return true;
}
//初始化操作
void SetupRC(){
    glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
    shaderManager.InitializeStockShaders();
    //开启深度测试
    glEnable(GL_DEPTH_TEST);
    //分配纹理队形：参数1：纹理对象个数 参数2：纹理对象指针
    glGenTextures(1, &textureID);
    //绑定纹理状态 参数1：纹理状态2D 参数2：纹理对象
    glBindTexture(GL_TEXTURE_2D, textureID);
    //将TGA文件加载为2D纹理
    //参数1：纹理文件名称
    //参数2&参数3：需要缩小&放大的过滤器
    //参数4：纹理坐标环绕模式
    LoadTGATexture("stone.tga", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR, GL_CLAMP_TO_EDGE);
    //创建金字塔pyramidBatch
    MakePyramid(pyramidBatch);
    
    //相机frame MoveForward（平移）
    //参数1：Z 深度（屏幕到图形的Z轴距离）
    cameraFrame.MoveForward(-10);
}

//清理 删除纹理对象
void ShutdownRC(void){
    glDeleteTextures(1, &textureID);
}

void RenderScene(void)
{
    //1.颜色值&光源位置
    static GLfloat vLightPos[] = {1.0f,1.0f,0.0f};//设置光源位置 X Y Z
    static GLfloat vWhite[] = {1.0f,1.0f,1.0f,1.0f}; //设置颜色 RGBA
    
    //清理缓存区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    //当前模型视图压栈
    modelViewMatrix.PushMatrix();
    //添加照相机矩阵
    M3DMatrix44f mCamera;
    //从cameraFrame中获取一个4 * 4的矩阵
    cameraFrame.GetCameraMatrix(mCamera);
    //矩阵乘以矩阵堆栈顶部矩阵，相乘的结果存储到堆栈的顶部 将照相机矩阵 与 当前模型矩阵相乘  压入栈顶
    modelViewMatrix.MultMatrix(mCamera);
    
    //创建mObjectFrame矩阵
    M3DMatrix44f mObjectFrame;
    //从objectFrame中获取矩阵，objectFrame保存的是特殊键位的变换矩阵
    objectFrame.GetMatrix(mObjectFrame);
    //矩阵乘以矩阵堆栈顶部矩阵 相乘结果存储到堆栈的顶部 将世界变换矩阵呢 与 当前模型矩阵相乘 压入栈顶
    modelViewMatrix.MultMatrix(mObjectFrame);
    
    
    //绑定纹理
    glBindTexture(GL_TEXTURE_2D, textureID);
    
    /*点光源着色器
     参数1： GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF (着色器标签)
     参数2：模型视图矩阵
     参数3：投影矩阵
     参数4：视点坐标系中光源的位置
     参数5：基本漫反射颜色
     参数6：图形颜色（用纹理就不需要设置颜色。设置为0）
     
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                 transformPipeline.GetModelViewMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vWhite,
                                 0);
    */
    
    /*
     纹理替换矩阵着色器
     参数1：GLT_SHADER_TEXTURE_REPLACE (着色器标签)
     参数2：模型视图投影矩阵
     参数3：纹理层
     */
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,
                                 transformPipeline.GetModelViewProjectionMatrix(),
                                 0);
    //绘制
    pyramidBatch.Draw();
    //模型视图出栈 恢复矩阵（push一次就要pop一次）
    modelViewMatrix.PopMatrix();
    //交换缓存区
    glutSwapBuffers();
    
}
void SpecialKeys(int key, int x ,int y)
{
    if (key == GLUT_KEY_UP) {//旋转度数 沿着x轴对称旋转 向外为正 向里为负
        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) {//沿着y轴旋转
        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.f);
    //获取viewFrustum投影矩阵,并将其加载到投影矩阵堆栈上
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    
    //设置变换管道以使用两个矩阵堆栈（变换矩阵modeViewMatrix,投影矩阵：projectionMatrix）
    //初始化GLGeometryTransform 的实例transformPipeline，
//    通过将它的内部指针设置为模型视图矩阵堆栈 和投影矩阵堆栈 实例，来完成初始化
    //当然这个操作也是可以在SetupRC函数中完成，但是在窗口大小改变时完成或者窗口创建时设置他们并没有坏处，而且这样可以一次性完成矩阵和管线的设置
    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;
}

• 球体效果

  
  旋转球

//  Created by apple on 2019/11/25.
//  Copyright © 2019年 apple. All rights reserved.
//

#include "GLTools.h"
#include "GLShaderManager.h"
#include "GLFrustum.h"
#include "GLBatch.h"
#include "GLFrame.h"
#include "GLMatrixStack.h"
#include "GLGeometryTransform.h"
#include "StopWatch.h"
#include <math.h>

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

//添加附加随机球
#define NUM_SPHERES 50
GLFrame             spheres[NUM_SPHERES];

GLShaderManager             shaderManager;
GLMatrixStack               modelViewMatrix;
GLMatrixStack               projectionMatrix;
GLFrustum                   viewFrustum;
GLGeometryTransform         transformPipeline;

GLTriangleBatch             torusBatch; //球批处理
GLBatch                     floorBatch; //地板批处理

GLTriangleBatch             sphereBatch; //球批处理
GLFrame                     cameraFrame;

//添加纹理 纹理标记数组
GLuint uiTextures[3];

bool LoadTGATexture(const char *szFileName, GLenum minFilter, GLenum magFilter, GLenum wrapMode)
{
    GLbyte *pBits;
    int nWidth,nHeight,nComponents;
    GLenum eFormat;
    
    //1.读取纹理数据
    pBits = gltReadTGABits(szFileName, &nWidth, &nHeight, &nComponents, &eFormat);
    if (pBits == NULL) {
        return false;
    }
    //2.设置纹理参数
    /*
     参数1：纹理维度
     参数2：为S/T 坐标设置模式
     参数3：wrapMode 环绕模式
     */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
    
    //参数1：纹理维度
    /*
     参数2：线性过滤
     参数3：wrapMode 环绕模式
     */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
    
    /*
     载入纹理
     参数1：纹理维度
     参数2：mip贴图层次
     参数3：纹理单元存储的颜色成分（从读取像素图获得）
     参数4：加载纹理宽
     参数5：加载纹理高
     参数6：加载纹理深度
     参数7：文件格式
     参数8：像素数据的数据类型（GL_UNSIGNED_BYTE,每个颜色分量都是一个8位无符号整数）
     参数9：指向纹理图像数据的指针
     */
    
    glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB, nWidth, nHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBits);
    //使用完毕释放pBits
    free(pBits);
    
    //只有minFilter 等于以下四种模式，才可以生成Mip贴图
    //GL_NEAREST_MIPMAP_NEAREST具有非常好的性能，并且闪烁现象非常弱
    //GL_LINEAR_MIPMAP_NEAREST常常用于对游戏进行加速，它使用了高质量的线性过滤器
    //GL_LINEAR_MIPMAP_LINEAR 和GL_NEAREST_MIPMAP_LINEAR 过滤器在Mip层之间执行了一些额外的插值，以消除他们之间的过滤痕迹。
    //GL_LINEAR_MIPMAP_LINEAR 三线性Mip贴图。纹理过滤的黄金准则，具有最高的精度。
    if(minFilter == GL_LINEAR_MIPMAP_LINEAR ||
       minFilter == GL_LINEAR_MIPMAP_NEAREST ||
       minFilter == GL_NEAREST_MIPMAP_LINEAR ||
       minFilter == GL_NEAREST_MIPMAP_NEAREST)
        //4.加载Mip,纹理生成所有的Mip层
        //参数：GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
        glGenerateMipmap(GL_TEXTURE_2D);
    
    return true;
}
void drawSomething(GLfloat yRot)
{
    //1.定义光源位置 & 漫反射颜色
    static GLfloat vWhite[] = {1.0f, 1.0f, 1.0f, 1.0f};
    static GLfloat vLightPos[] = { 0.0f, 3.0f, 0.0f, 1.0f };

    //2.绘制悬浮小球球
    glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
    for(int i = 0; i < NUM_SPHERES; i++) {
        modelViewMatrix.PushMatrix();
        modelViewMatrix.MultMatrix(spheres[I]);
        shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                     modelViewMatrix.GetMatrix(),
                                     transformPipeline.GetProjectionMatrix(),
                                     vLightPos,
                                     vWhite,
                                     0);
        sphereBatch.Draw();
        modelViewMatrix.PopMatrix();
    }
    
    //3.绘制大球球
    modelViewMatrix.Translate(0.0f, 0.2f, -2.5f);
    modelViewMatrix.PushMatrix();
    modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                 modelViewMatrix.GetMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vWhite,
                                 0);
    torusBatch.Draw();
    modelViewMatrix.PopMatrix();
    
    //4.绘制公转小球球（公转自转)
    modelViewMatrix.PushMatrix();
    modelViewMatrix.Rotate(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
    modelViewMatrix.Translate(0.8f, 0.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                 modelViewMatrix.GetMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vWhite,
                                 0);
    sphereBatch.Draw();
    modelViewMatrix.PopMatrix();
    
    
}
//进行调用以绘制场景
void RenderScene(void){
    //1.地板颜色值
    static GLfloat  vFloorColor[] = {1.0f,1.0f,0.0f,0.75f};
    //2.基于时间动画
    static CStopWatch rotTimer;
    float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
    
    //3.清除颜色缓存区和深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //4.压入栈(栈顶)
    modelViewMatrix.PushMatrix();
    //5.设置观察者矩阵
    M3DMatrix44f mCamera;
    cameraFrame.GetCameraMatrix(mCamera);
    modelViewMatrix.MultMatrix(mCamera);
    
    //6.压栈（镜面）
    modelViewMatrix.PushMatrix();
    //7.添加反光效果
    //翻转Y轴
    modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
    //镜面世界围绕Y轴平移一定间距
    modelViewMatrix.Translate(0.0f, 0.8f, 0.0f);
    
    //8.指定顺时针为正面
    glFrontFace(GL_CW);
    
    //9.绘制地面以外其他部分（镜面）
    drawSomething(yRot);
    //10.恢复为逆时针正面
    glFrontFace(GL_CCW);
    
    //11.绘制镜面 恢复矩阵
    modelViewMatrix.PopMatrix();
    
    //12.开启混合功能（绘制地板）
    glEnable(GL_BLEND);
    //13. 指定glBlendFunc 颜色混合方程式
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    //14.绑定地面纹理
    glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
    
    /*15.
     纹理调整着色器(将一个基本色乘以一个取自纹理的单元nTextureUnit的纹理)
     参数1：GLT_SHADER_TEXTURE_MODULATE
     参数2：模型视图投影矩阵
     参数3：颜色
     参数4：纹理单元（第0层的纹理单元）
     
     */
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
                                 transformPipeline.GetModelViewProjectionMatrix(),
                                 vFloorColor,
                                 0);
    //开始绘制
    floorBatch.Draw();
    //取消混合
    glDisable(GL_BLEND);
    
    //16.绘制地面以外其他部分
    drawSomething(yRot);
    
    //17.绘制完，恢复矩阵
    modelViewMatrix.PopMatrix();
    
    //18.交换缓存区
    glutSwapBuffers();
    
    //19.提交重新渲染
    glutPostRedisplay();
    
    
}
void ChangeSize(int width ,int height){
    //1、设置视口
    glViewport(0, 0, width, height);
    //2.设置投影方式
    viewFrustum.SetPerspective(35.f, float(width)/float(height), 1.0f, 100.f);
    //3.将投影矩阵加载到投影矩阵堆栈
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    modelViewMatrix.LoadIdentity();
    //4.将投影矩阵堆栈和模型视图矩阵对象设置到管道中
    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
}

void SetupRC(){
    //1设置清屏颜色到颜色缓冲区
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    //2初始化着色器管理器
    shaderManager.InitializeStockShaders();
    //3.开启深度测试、背面剔除
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    
    //4.设置大球球
    gltMakeSphere(torusBatch, 0.4f, 40, 80);
    //5.设置小球
    gltMakeSphere(sphereBatch, 0.1f, 26, 13);
    //6.设置地板顶点数据&地板纹理
    GLfloat texSize = 10.0f;
    floorBatch.Begin(GL_TRIANGLE_FAN, 4,1);
    //设置纹理坐标 第一个参数：纹理层次 对于使用纹理着色器来进行渲染 设置为0
    floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    floorBatch.Vertex3f(-20.f, -0.41f, 20.f);
    
    floorBatch.MultiTexCoord2f(0, texSize, 0.0f);
    floorBatch.Vertex3f(20.0f, -0.41f, 20.f);
    
    floorBatch.MultiTexCoord2f(0, texSize, texSize);
    floorBatch.Vertex3f(20.0f, -0.41f, -20.0f);
    
    floorBatch.MultiTexCoord2f(0, 0.0f, texSize);
    floorBatch.Vertex3f(-20.0f, -0.41f, -20.0f);
    floorBatch.End();
    
    //7. 随机小球球顶点坐标数据
    for (int i = 0; i< NUM_SPHERES; i++) {
        //y轴不变 X Z产生随机值
        GLfloat x = ((GLfloat)((rand() % 400) - 200) * 0.1f);
        GLfloat z = ((GLfloat)((rand() % 400) - 200 ) * 0.1f);
        
        //在y方向，将球体设置为0.0的位置，这使得它们看起来是飘浮在眼睛的高度
        //对spheres数组中的每一个顶点，设置顶点数据
        spheres[i].SetOrigin(x, 0.0f, z);
    }
    //8.命名纹理对象
    glGenTextures(3, uiTextures);
    //9.将TGA文件加载为2D纹理
    /*
     参数1:纹理文件名称
     参数2：3 需要缩小&放大的过滤器
     参数4：纹理坐标环绕模式
     */
    glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
    LoadTGATexture("marble.tga", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_REPEAT);
    
    
    glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
    LoadTGATexture("marslike.tga", GL_LINEAR_MIPMAP_LINEAR,
                   GL_LINEAR, GL_CLAMP_TO_EDGE);
    
    
    glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
    LoadTGATexture("moonlike.tga", GL_LINEAR_MIPMAP_LINEAR,
                   GL_LINEAR, GL_CLAMP_TO_EDGE);
    
}
void SpeacialKeys(int key ,int x, int y){
    float linear = 0.1f;
    float angular = float(m3dDegToRad(5.0f));
    
    if (key == GLUT_KEY_UP) {
        
        //MoveForward 平移
        cameraFrame.MoveForward(linear);
    }
    
    if (key == GLUT_KEY_DOWN) {
        cameraFrame.MoveForward(-linear);
    }
    
    if (key == GLUT_KEY_LEFT) {
        //RotateWorld 旋转
        cameraFrame.RotateWorld(angular, 0.0f, 1.0f, 0.0f);
    }
    
    if (key == GLUT_KEY_RIGHT) {
        cameraFrame.RotateWorld(-angular, 0.0f, 1.0f, 0.0f);
    }
}
void ShutdownRC(){
    glDeleteTextures(3, uiTextures);
}