[OpenGL]纹理贴图实现 总结

时间：2022-01-14 17:10:00

实现步骤

第一步：设置所需要的OpenGL环境

设置上下文环境

删除已经存在的渲染的缓存

设置颜色缓存

设置帧缓存

清除缓存

设置窗口大小

开启功能

编译shander

使用program

获取shader中的属性和uniform索引

第二步：绘制图片

获取图片数据并且的到对应的纹理id

指定纹理，绑定纹理

开始对图形进行渲染

(

启用顶点属性数组纹理坐标，将纹理坐标传递到shader中

启用顶点属性数组顶点坐标，将顶点坐标传递到shader中

启用索引数组

开始绘制

)

解绑纹理

实现

这次实现的过程有些艰难啊，走了很多的弯路，不过也因此学到蛮多的，自己写的怎么都运行不了，但是在别人的基础上运行就不行，其中错误的地方有：1.纹理的数据错误，使用png的库失败；2.绘制函数的参数错误；3.使用新版本的glsl语言版本，但是xcode并不支持，并不熟悉期间的语言版本迭代；

实现代码：

主程序

#include "SOIL.h"

static void error_callback(int error, const char* description)

{

    fprintf(stderr, "Error: %s\n", description);

}

int main(void)

{

    GLFWwindow* window;

    glfwSetErrorCallback(error_callback);

    if (!glfwInit())

        exit(EXIT_FAILURE);

    window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL);

    if (!window)

    {

        std::cout << "Failed to create GLFW window" << std::endl;

        glfwTerminate();

        exit(EXIT_FAILURE);

    }

    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;

    glewInit();

    glfwSwapInterval(1);

    glViewport(0, 0, 640, 480);

    bool ret = getImageData("/Users/staff/Desktop/Moni/Moni/wall.png");

    if (!ret) {

        cout << "get iamge data is failed." << endl;

    }

    else {

        cout << "get iamge data is success." << endl;

        //测试图片数据

        //        FILE * file;

        //        file = fopen("/Users/staff/Desktop/abc.png","wb");

        //        if (file)

        //        {

        //            fwrite(_sp_image_data.getBytes(),1,_sp_image_data.getSize(), file);

        //        }

        //        fclose(file);

    }

    // 第一行和第三行不是严格必须的，默认使用GL_TEXTURE0作为当前激活的纹理单元

    /**

     *  GL_TEXTURE_2D表示操作2D纹理

     *  创建纹理对象，

     *  绑定纹理对象，

     */

    glPixelStorei(GL_UNPACK_ALIGNMENT, 8);

    glGenTextures(1, &_sp_textureID);

    glBindTexture(GL_TEXTURE_2D, _sp_textureID);

    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 );

    /**

     *  将图像数据传递给到GL_TEXTURE_2D中, 因其于textureID纹理对象已经绑定，所以即传递给了textureID纹理对象中。

     *  glTexImage2d会将图像数据从CPU内存通过PCIE上传到GPU内存。

     *  不使用PBO时它是一个阻塞CPU的函数，数据量大会卡

     */

//    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _sp_image_size.getX(), _sp_image_size.getY(), 0, GL_RGBA, GL_UNSIGNED_BYTE, _sp_image_data.getBytes());

//    glGenerateMipmap(GL_TEXTURE_2D);

    int width, height;

    unsigned char* image = SOIL_load_image("/Users/staff/Desktop/fgh/fgh/wall.jpg", &width, &height, 0, SOIL_LOAD_RGB);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);

    glGenerateMipmap(GL_TEXTURE_2D);

    SOIL_free_image_data(image);

    glBindTexture(GL_TEXTURE_2D, 0);

    _vertexShader = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(_vertexShader, 1, &CCPositionTextureColorVert, NULL);

    glCompileShader(_vertexShader);

    GLint status;

    glGetShaderiv(_vertexShader, GL_COMPILE_STATUS, &status);

    if (!status) {

        GLint infoLen = 0;

        glGetShaderiv(_vertexShader, GL_INFO_LOG_LENGTH, &infoLen);

        if (infoLen) {

            char* infoLog = static_cast<char *>(malloc(sizeof(char) * infoLen));

            glGetShaderInfoLog(_vertexShader, infoLen, NULL, infoLog);

            cout << "compile vert shader wrong..." << infoLog << endl;

        }

    }

    else {

        cout << "compile vert shader success..." << endl;

    }

    _fragShader = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(_fragShader, 1, &CCPositionTextureColorFrag, NULL);

    glCompileShader(_fragShader);

    glGetShaderiv(_fragShader, GL_COMPILE_STATUS, &status);

    if (!status) {

        GLint infoLen = 0;

        glGetShaderiv(_fragShader, GL_INFO_LOG_LENGTH, &infoLen);

        if (infoLen) {

            char* infoLog = static_cast<char *>(malloc(sizeof(char) * infoLen));

            glGetShaderInfoLog(_fragShader, infoLen, NULL, infoLog);

            cout << "compile frag shader wrong..." << infoLog << endl;

        }

    }

    else {

        cout << "compile vert frag success..." << endl;

    }

    _program = glCreateProgram();

    glAttachShader(_program, _vertexShader);

    glAttachShader(_program, _fragShader);

    glLinkProgram(_program);

    glGetProgramiv(_program, GL_LINK_STATUS, &status);

    if (status == GL_FALSE) {

        GLint infoLen = 0;

        glGetProgramiv(_program, GL_INFO_LOG_LENGTH, &infoLen);

        if (infoLen) {

            char* infoLog = static_cast<char *>(malloc(sizeof(char) * infoLen));

            glGetProgramInfoLog(_program, infoLen, NULL, infoLog);

            cout << "link program wrong..." << infoLog << endl;

        }

    }

    else {

        cout << "the program link success." << endl;

    }

    //设置顶点数据（和缓冲）和属性指针

    GLfloat vertices[] = {

        // Positions          // Colors           // Texture Coords

        0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   2.0f, 0.1f,

        0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   2.0f, 0.8f,

        -0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.5f, 0.8f,

        -0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.5f, 0.1f

    };

    GLuint indices[] = {

        0, 1, 3,

        1, 2, 3

    };

    GLuint VBO, VAO, EBO;

    glGenVertexArrays(1, &VAO);

    glGenBuffers(1, &VBO);

    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    GLuint _positionSlot = glGetAttribLocation(_program, "position");

    GLuint _colorSlot = glGetAttribLocation(_program, "color");

    GLuint _textureCoordsSlot = glGetAttribLocation(_program, "texCoord");

    //GLuint _textureSlot = glGetUniformLocation(shader.program, "ourTexture");

    glVertexAttribPointer(_positionSlot, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);

    glEnableVertexAttribArray(_positionSlot);

    glVertexAttribPointer(_colorSlot, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));

    glEnableVertexAttribArray(_colorSlot);

    glVertexAttribPointer(_textureCoordsSlot, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));

    glEnableVertexAttribArray(_textureCoordsSlot);

    glBindVertexArray(0);

    while (!glfwWindowShouldClose(window))

    {

        glfwPollEvents();

        int width, height;

        glfwGetFramebufferSize(window, &width, &height);

        glViewport(0, 0, width, height);

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);

        glClear(GL_COLOR_BUFFER_BIT);

        //use

        glUseProgram(_program);

        glEnable(GL_BLEND);

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, _sp_textureID); // 绑定，即可从_textureID中取出图像数据

        glUniform1i(glGetUniformLocation(_program, "ourTexture1"), 0);

        //draw

        glBindVertexArray(VAO);

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        glBindVertexArray(0);

        glfwPollEvents();

        glfwSwapBuffers(window);

    }

    glDeleteVertexArrays(1, &VAO);

    glDeleteBuffers(1, &VBO);

    glDeleteBuffers(1, &EBO);

    glfwDestroyWindow(window);

    glfwTerminate();

    exit(EXIT_SUCCESS);

}

上面是主程序的代码，除了这个，还需要顶点shader和片元shader；其实这里有个坑，就是glsl的语言版本，越望越后面，增加了更多的新 功能，导致我不认识，从而使用了新版本的，同时xcode只更新了到了2.0上，其他版本在xcode并不能使用，因此导编编译失败。

先是顶点shader：

const char* CCPositionTextureColorVert = STRINGIFY(

attribute vec3 position;

attribute vec3 color;

attribute vec2 texCoord;

varying vec3 ourColor;

varying vec2 TexCoord;

void main() {

    gl_Position = vec4(position, 1.0);

    ourColor = color;

    TexCoord = texCoord;

}

);

接下来的是片元shader

const char* CCPositionTextureColorFrag = STRINGIFY(

varying vec3 ourColor;

varying vec2 TexCoord;

//varying vec4 color;

uniform sampler2D ourTexture1;

uniform sampler2D ourTexture2;

uniform float mixValue;

void main() {

    gl_FragColor = mix(texture2D(ourTexture1, TexCoord) * vec4(ourColor, 1.0), texture2D(ourTexture2, vec2(-TexCoord.x, TexCoord.y)), mixValue);

}

);

相关文章