C++ 加载多纹理opengl es 2.0

我在互联网上找到了这段关于如何在opengl es 2.0中加载多重纹理的代码：

//
// Book:      OpenGL(R) ES 2.0 Programming Guide
// Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
// ISBN-10:   0321502795
// ISBN-13:   9780321502797
// Publisher: Addison-Wesley Professional
// URLs:      http://safari.informit.com/9780321563835
//            http://www.opengles-book.com
//

// MultiTexture.c
//
//    This is an example that draws a quad with a basemap and
//    lightmap to demonstrate multitexturing.
//
#include"pch.h"
#include <stdlib.h>

typedef struct
{
    // Handle to a program object
    GLuint programObject;

    // Attribute locations
    GLint  positionLoc;
    GLint  texCoordLoc;

    // Sampler locations
    GLint baseMapLoc;
    GLint lightMapLoc;

    // Texture handle
    GLuint baseMapTexId;
    GLuint lightMapTexId;

} UserData;


///
// Load texture from disk
//
GLuint LoadTexture(char *fileName)
{
    int width,
        height;
    char *buffer = esLoadTGA(fileName, &width, &height);
    GLuint texId;

    if (buffer == NULL)
    {
        esLogMessage("Error loading (%s) image.\n", fileName);
        return 0;
    }

    glGenTextures(1, &texId);
    glBindTexture(GL_TEXTURE_2D, texId);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    free(buffer);

    return texId;
}



///
// Initialize the shader and program object
//
int Init(ESContext *esContext)
{
    UserData *userData = (UserData*) esContext->userData;
    const char vShaderStr[] =
        "attribute vec4 a_position;   \n"
        "attribute vec2 a_texCoord;   \n"
        "varying vec2 v_texCoord;     \n"
        "void main()                  \n"
        "{                            \n"
        "   gl_Position = a_position; \n"
        "   v_texCoord = a_texCoord;  \n"
        "}                            \n";

    const char fShaderStr[] =
        "precision mediump float;                            \n"
        "varying vec2 v_texCoord;                            \n"
        "uniform sampler2D s_baseMap;                        \n"
        "uniform sampler2D s_lightMap;                       \n"
        "void main()                                         \n"
        "{                                                   \n"
        "  vec4 baseColor;                                   \n"
        "  vec4 lightColor;                                  \n"
        "                                                    \n"
        "  baseColor = texture2D( s_baseMap, v_texCoord );   \n"
        "  lightColor = texture2D( s_lightMap, v_texCoord ); \n"
        "  gl_FragColor = baseColor * (lightColor + 0.25);   \n"
        "}                                                   \n";

    // Load the shaders and get a linked program object
    userData->programObject = esLoadProgram(vShaderStr, fShaderStr);


    // Get the attribute locations
    userData->positionLoc = glGetAttribLocation(userData->programObject, "a_position");
    userData->texCoordLoc = glGetAttribLocation(userData->programObject, "a_texCoord");

    // Get the sampler location
    userData->baseMapLoc = glGetUniformLocation(userData->programObject, "s_baseMap");
    userData->lightMapLoc = glGetUniformLocation(userData->programObject, "s_lightMap");

    // Load the textures
    userData->baseMapTexId = LoadTexture("basemap.tga");
    userData->lightMapTexId = LoadTexture("lightmap.tga");

    if (userData->baseMapTexId == 0 || userData->lightMapTexId == 0)
        return FALSE;

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    return TRUE;
}

///
// Draw a triangle using the shader pair created in Init()
//
void Draw(ESContext *esContext)
{
    UserData *userData = (UserData*)esContext->userData;
    GLfloat vVertices[] = { -0.5f, 0.5f, 0.0f,  // Position 0
        0.0f, 0.0f,        // TexCoord 0 
        -0.5f, -0.5f, 0.0f,  // Position 1
        0.0f, 1.0f,        // TexCoord 1
        0.5f, -0.5f, 0.0f,  // Position 2
        1.0f, 1.0f,        // TexCoord 2
        0.5f, 0.5f, 0.0f,  // Position 3
        1.0f, 0.0f         // TexCoord 3
    };
    GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

    // Set the viewport
    glViewport(0, 0, esContext->width, esContext->height);

    // Clear the color buffer
    glClear(GL_COLOR_BUFFER_BIT);

    // Use the program object
    glUseProgram(userData->programObject);

    // Load the vertex position
    glVertexAttribPointer(userData->positionLoc, 3, GL_FLOAT,
        GL_FALSE, 5 * sizeof(GLfloat), vVertices);
    // Load the texture coordinate
    glVertexAttribPointer(userData->texCoordLoc, 2, GL_FLOAT,
        GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3]);

    glEnableVertexAttribArray(userData->positionLoc);
    glEnableVertexAttribArray(userData->texCoordLoc);

    // Bind the base map
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, userData->baseMapTexId);

    // Set the base map sampler to texture unit to 0
    glUniform1i(userData->baseMapLoc, 0);

    // Bind the light map
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, userData->lightMapTexId);

    // Set the light map sampler to texture unit 1
    glUniform1i(userData->lightMapLoc, 1);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);

    eglSwapBuffers(esContext->eglDisplay, esContext->eglSurface);
}

///
// Cleanup
//
void ShutDown(ESContext *esContext)
{
    UserData *userData = (UserData*)esContext->userData;

    // Delete texture object
    glDeleteTextures(1, &userData->baseMapTexId);
    glDeleteTextures(1, &userData->lightMapTexId);

    // Delete program object
    glDeleteProgram(userData->programObject);
}


int main(int argc, char *argv[])
{
    ESContext esContext;
    UserData  userData;

    esInitContext(&esContext);
    esContext.userData = &userData;

    esCreateWindow(&esContext, L"MultiTexture", 320, 240, ES_WINDOW_RGB);

    if (!Init(&esContext))
        return 0;

    esRegisterDrawFunc(&esContext, Draw);

    esMainLoop(&esContext);

    ShutDown(&esContext);
}

//
//书籍：OpenGL（R）ES 2.0编程指南
//作者：Aaftab Munshi，Dan Ginsburg，Dave Shriner
//ISBN-10:032150795
//ISBN-13:9780321502797
//出版人：艾迪生·卫斯理专业版
//网址：http://safari.informit.com/9780321563835
//            http://www.opengles-book.com
//
//多织物
//
//这是一个使用底图和
//用于演示多重文本的光照图。
//
#包括“pch.h”
#包括
类型定义结构
{
//程序对象的句柄
GLuint程序对象；
//属性位置
闪烁定位；
闪烁的texCoordLoc；
//取样器位置
闪烁baseMapLoc；
闪烁光；
//纹理句柄
GLuint baseMapTexId；
GLuint lightMapTexId；
}用户数据；
///
//从磁盘加载纹理
//
GLuint LoadTexture（字符*文件名）
{
整数宽度，
身高
char*buffer=esLoadTGA（文件名、宽度和高度）；
胶状体；
if（buffer==NULL）
{
esLogMessage（“加载（%s）图像时出错。\n”，文件名）；
返回0；
}
glGenTextures（1和texId）；
glBindTexture（GL_TEXTURE_2D，texId）；
GLTEXAGE2D（GL_纹理_2D，0，GL_RGB，宽度，高度，0，GL_RGB，GL_无符号字节，缓冲区）；
glTexParameteri（GL_纹理2D、GL_纹理最小过滤器、GL_线性）；
glTexParameteri（GL_纹理2D、GL_纹理MAG_过滤器、GL_线性）；
glTexParameteri（GL_纹理_2D、GL_纹理_包裹、GL_夹紧_至_边缘）；
glTexParameteri（GL_纹理\u 2D、GL_纹理\u包裹\u T、GL_夹紧\u至\u边缘）；
自由（缓冲）；
返回texId；
}
///
//初始化着色器和程序对象
//
int Init（ESContext*ESContext）
{
UserData*UserData=（UserData*）esContext->UserData；
常量字符vShaderStr[]=
“属性向量4 a_位置；\n”
“属性vec2 a_texCoord；\n”
“可变的vec2 v_texCoord；\n”
“void main（）\n”
“{\n”
“gl\U位置=a\U位置；\n”
“v_texCoord=a_texCoord；\n”
“}\n”；
常量字符fShaderStr[]=
“精度中间泵浮动；\n”
“可变的vec2 v_texCoord；\n”
“统一二维采样器\u底图；\n”
“统一二维采样器\u光照贴图；\n”
“void main（）\n”
“{\n”
“vec4基色；\n”
“vec4 lightColor；\n”
“\n”
baseColor=texture2D（s_baseMap，v_texCoord）；\n
lightColor=texture2D（s_lightMap，v_texCoord）；\n
“gl_FragColor=baseColor*（lightColor+0.25）；\n”
“}\n”；
//加载着色器并获取链接的程序对象
userData->programObject=esLoadProgram（vShaderStr，fShaderStr）；
//获取属性位置
userData->positionLoc=GLGetAttriblLocation（userData->programObject，“a_位置”）；
userData->texCoordLoc=glGetAttribLocation（userData->programObject，“a_texCoord”）；
//获取取样器的位置
userData->baseMapLoc=glGetUniformLocation（userData->programObject，“s_baseMap”）；
userData->lightMapLoc=glGetUniformLocation（userData->programObject，“s_lightMap”）；
//加载纹理
userData->baseMapTexId=LoadTexture（“basemap.tga”）；
userData->lightMapTexId=LoadTexture（“lightmap.tga”）；
如果（userData->baseMapTexId==0 | | userData->lightMapTexId==0）
返回FALSE；
glClearColor（0.0f、0.0f、0.0f、0.0f）；
返回TRUE；
}
///
//使用在Init（）中创建的着色器对绘制三角形
//
无效绘制（ESContext*ESContext）
{
UserData*UserData=（UserData*）esContext->UserData；
GLfloat vVertices[]={-0.5f，0.5f，0.0f，//位置0
0.0f，0.0f，//TexCoord 0
-0.5f，-0.5f，0.0f，//位置1
0.0f，1.0f，//TexCoord 1
0.5f，-0.5f，0.0f，//位置2
1.0f，1.0f，//TexCoord 2
0.5f、0.5f、0.0f、//位置3
1.0f，0.0f//TexCoord 3
};
GLushort指数[]={0,1,2,0,2,3}；
//设置视口
glViewport（0,0，esContext->width，esContext->height）；
//清除颜色缓冲区
glClear（GLU颜色缓冲位）；
//使用程序对象
glUseProgram（userData->programObject）；
//加载顶点位置
GLVertexAttributePointer（用户数据->位置锁定，3，GL\U浮点，
GL_假，5*sizeof（GLfloat），vVertices）；
//加载纹理坐标
GLVERtexAttributePointer（用户数据->texCoordLoc，2，GL\u浮点，
GL_FALSE，5*sizeof（GLfloat）和vVertices[3]；
GlenableVertexAttributeArray（userData->positionLoc）；
GlenableVertexAttributeArray（userData->texCoordLoc）；
//绑定底图
玻璃纹理（GL_纹理0）；
glBindTexture（GL_TEXTURE_2D，userData->baseMapTexId）；
//将“基础贴图采样器”的“纹理单位”设置为0
glUniform1i（userData->baseMapLoc，0）；
//绑定灯光贴图
玻璃结构（GL_纹理1）；
glBindTexture（GL_TEXTURE_2D，用户数据->lightMapTexId）；
//将灯光贴图采样器设置为纹理单元1
glUniform1i（userData->lightMapLoc，1）；
GLD元素（GL_三角形，6，GL_无符号_短，索引）；
eglSwapBuffers（esContext->eglDisplay，esContext->eglSurface）；
}
///
//清理
//
无效关闭（ESContext*ESContext）
{
UserData*UserData=（UserData*）esContext->UserData；
//删除纹理对象
glDeleteTextures（1，&userData->baseMapTexId）；
glDeleteTextures（1，&userData->lightMapTexId）；
//删除程序对象
glDeleteProgram（用户数据->程序对象）；
}
int main（int argc，c
void cColorTest::ForceCommitTexture(unsigned int texId)
{
glUseProgram(m_nProgram);
glBindTexture(GL_TEXTURE_2D,texId);
GLfloat triangle[]= {   0.0f,  0.5f, 0.5f,  1.0f,   1.0f, 0.0f,
                        -0.5f, -0.5f, 0.5f, 1.0f,   0.0f, 1.0f,
                        0.5f, -0.5f, 0.5f,  1.0f,   0.0f, 0.0f};

glVertexAttribPointer ( m_nPosLoc, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(float), triangle );
glEnableVertexAttribArray ( m_nPosLoc );
glVertexAttribPointer ( m_nUVLoc, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(float), triangle + 4 );
glEnableVertexAttribArray ( m_nUVLoc );

glDrawArrays(GL_TRIANGLES,0,1);

}