OpenGL学习（三）第一个三角形

前言

学习opencv英文网址：https://learnopengl.com/#!Getting-started/Hello-Triangle

中文翻译：https://learnopengl-cn.github.io/01%20Getting%20started/04%20Hello%20Triangle/

相关代码：https://github.com/JoeyDeVries/LearnOpenGL

本文采用的代码有相关的修改，更易于理解学习

名词术语

 opengl管线

  opengl3.0区别之前不再采用固定管线的编程，而是采用可编程的管线，给了开发者更多的自由度，但是也是因为这个原因，opengl的学习门槛又变高了一些。

下面是红宝书中关于固定管线的图

这张图主要是介绍了opengl的具体管线的包含的着色器。现在大家先有这样一个概念就好了。opengl程序可以看成这样子一个过程。我们从最原始的一个水池将水用水管导到不同的池子里面，最后那个水池输出的水就是我们需要的，而不同的池子就相当于着色器，池子可能进行不同的化学物理处理（eg：过滤）相当于着色器的不同操作。

下面这一张是opengl 4.5官方手册中的

和这个封面的图主要是介绍了各个着色器之间的数据流通。后面需要详细的解析

 核心模式和兼容模式

  opengl从3.1版本开始就抛弃基于固定管线的编程。在GLSL开头需要指定采用的是核心模式还是兼容模式，核心模式仅支持基于着色器的编程；而兼容模式还包括了一个固定管线。

 顶点对象和缓存对象
  顶点对象中存放的是缓存对象的地址，而缓存对象中存放的是真正的数据内容。具体看图。

代码分析

 代码下载

  http://download.csdn.net/detail/zhouyelihua/9885329

 关键代码段分析

   unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);//创建一个顶点数组
    glGenBuffers(1, &VBO);//创建一个缓存对象
    glBindVertexArray(VAO);//绑定顶点数组，记住绑定操作有点类似阀门，后续所有的操作都会基于这个绑定的对象
    glBindBuffer(GL_ARRAY_BUFFER, VBO);//指定当前的缓存对象的类型
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);//用来给指定的buffer，绑定数据，如果绑定的的对象之前有关联的对象，则会先删除关联的对象
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

  

 代码

#include<iostream>
#include <glad/glad.h>
#include <GLFW/glfw3.h>

void framebuffer_size_callback(GLFWwindow* window, int width, int height)//这个是窗口变化的回调函数。。注意输入参数
                                                                         //是一个glfw的窗口，一个宽度和高度
{
    glViewport(0, 0, width, height);//这个是回调函数内的内容
                                    //这里是将视口改成变化后的的窗口大小
                                    //注意需要的注册该回调函数
                                    //glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
                                    //两个参数是，glfw的窗口以及回调函数
}
void processInput(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//获取按键，如果等于esc 
        glfwSetWindowShouldClose(window, true);//利用强制窗口应该关闭
}
GLuint loadShader(GLenum type, const char *shaderSrc) {//加载着色器
    GLuint shader;
    GLint complied;
    shader = glCreateShader(type);//创建着色器
    if (shader == 0)//创建失败
        return 0;
    glShaderSource(shader, 1, &shaderSrc, NULL);//加载着色器程序，第一个参数是创建的着色器编号，
                                                                //第二个程序是着色器的数量，此处默认是1
                                                                //第三个是着色器的输入
    glCompileShader(shader);                    //编译着色器
    glGetShaderiv(shader, GL_COMPILE_STATUS, &complied);//获取着色器的编译状态
    if (!complied) {                                    //查看错误信息
        GLint infoLen = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen > 1) {
            char* infoLog = (char*)(malloc(sizeof(sizeof(char)*infoLen)));
            std::cout << "Error compling shader:\n" << infoLog << "\n";
            free(infoLog);
        }
        glDeleteShader(shader);
        return 0;
    }
    return shader;
}
/*
顶点着色器处理顶点相关的任何事情，也可能是简单的进行定点的数据传递
一个复杂的应用程序可能包含很多的顶点着色器，但是同一个时刻只能有一个在起作用
*/
unsigned int vertexShader() {//顶点着色器
    char vertexShaderSource[] =
        "#version 450 core                                      \n"             /*版本号*/
        "layout(location = 0) in vec3 aPos;                     \n"
        "void main()                                            \n"
        "{                                                      \n"
        "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);    \n"
        "}                                                      \n";
    unsigned int vertexShader;
    vertexShader = loadShader(GL_VERTEX_SHADER, vertexShaderSource);
    std::cout << vertexShader << std::endl;
    return vertexShader;
}
/*
片元着色器通过编程控制屏幕上的显示颜色的阶段，叫做片元着色阶段

*/
unsigned int fragmentShader() {//片元着色器

    char fragmentShaderSource[] =
        "#version 450 core                                  \n"
        "out vec4 FragColor;                                \n"
        "void main()                                        \n"
        "{                                                  \n"
        "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);       \n"
        "}                                                  \n";
    unsigned int fragmentShader;
    fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
    std::cout << fragmentShader << std::endl;
    return fragmentShader;
}

int main()
{
    glfwInit();//类似于之前的gluinit一般采用库都需要进行初始化
               //版本号是opengl4.5
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);//设置主版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);//设置次版本号
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);//在mac系统上需要设置该语句
    GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);//后面两个参数是设置显示屏和共享的，
                                                                               //一般库函数的相关定义，
                                                                               //可以配置好以后直接查看都有详细的定义
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))//在调用opengl函数之前初始化glad，
                                                            //glad的作用就是快速的将opengl函数映射到相关的显卡函数上
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }
    glViewport(0, 0, 800, 600);//设置视口大小
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);//注册函数，该函数还可以注册其他相关硬件的回调函数
                                                                  //
    unsigned int shaderProgram;
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader());
    glAttachShader(shaderProgram, fragmentShader());
    glLinkProgram(shaderProgram);
    int success;
    char infoLog[512];
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader());
    glDeleteShader(fragmentShader());
    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f,
        0.0f,  0.5f, 0.0f
    };
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

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

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0);


    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // render loop

    //渲染流程
    while (!glfwWindowShouldClose(window))//检测glfw窗口是否被指令要求关闭，如果是的话，则会退出循环
    {

        //输入的相关操作
        processInput(window);//
        // 渲染的相关操作
        glClearColor(0.0f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        // draw our first triangle
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
        glDrawArrays(GL_TRIANGLES, 0, 3);
        //查看所有的事件，并且交换内存
        glfwSwapBuffers(window);//交换颜色缓存，即glfw窗口内的内容。。。注意glfw开头的交换和后面gl开头的区别
        glfwPollEvents();//检测是否有其他的触发时间，例如上述的窗口大小变化，需要调用相关的回调函数
    }
    glfwTerminate();//清除退出
    return 0;
}

 实验结果

如果您觉得此博客对您有用，欢迎对我进行小额赞助。

不筹钱娶媳妇的程序员不是好程序员！