OPENGL 初学习（一） —— 绘制三角形

1. glfw用途：

        1. 窗口管理：GLFW 可以创建窗口，处理窗口大小和位置的改变，以及其他与窗口相关的事件。

        2. 输入处理：GLFW 可以处理键盘、鼠标和游戏手柄的输入

        3. opengl上下文： 在不同的操作系统上创建和初始化 OpenGL 上下文之后，可以主要使用 OpenGL 的接口进行图形编程

2. 编写流程：

准备工作

        1. GLFW初始化

        2. GLFW创建窗口

        3. 着色器程序（着色器(Shader)是运行在GPU上的小程序，（GLSL，着色器是使用一种叫GLSL的类C语言写成的）：顶点与片段着色器创建编译与程序连接

        4. 创建顶点数据与VB0 VAO；

        5. 绑定VAO

        6. 绑定并填充VBO到GL_ARRAY_BUFFER 

        7. 设置并启用顶点属性：定义了如何从 VBO（当前绑定到 GL_ARRAY_BUFFER 目标的缓冲）中读取顶点数据

        8. VBO 解绑

        9. VAO 解绑

绘制工作：

        1. 响应外部输入

        2. 背景清理

        3. 调用程序

        4.绑定VAO

        5. glDrawArrays 图元绘制

        6. glfw双缓冲交换

        7. glfw检查并调用事件处理，查询IO事件

    下面代码转载自opengl 你好三角形教程

#include <glad/glad.h>

#include <GLFW/glfw3.h>

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);

void processInput(GLFWwindow *window);

// settings

const unsigned int SCR_WIDTH = 800;

const unsigned int SCR_HEIGHT = 600;

const char *vertexShaderSource = "#version 330 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"

    "}\0";

const char *fragmentShaderSource = "#version 330 core\n"

    "out vec4 FragColor;\n"

    "void main()\n"

    "{\n"

    "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"

    "}\n\0";

int main()

{

    // glfw: initialize and configure

    // ------------------------------

    glfwInit();

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__

    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

#endif

    // glfw window creation

    // --------------------

    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);

    if (window == NULL)

    {

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

        glfwTerminate();

        return -1;

    }

    glfwMakeContextCurrent(window);

    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers

    // ---------------------------------------

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))

    {

        std::cout << "Failed to initialize GLAD" << std::endl;

        return -1;

    }

 

    // build and compile our shader program

    // ------------------------------------

    // vertex shader

    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);

    glCompileShader(vertexShader);

    // check for shader compile errors

    int success;

    char infoLog[512];

    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

    if (!success)

    {

        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);

        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;

    }

    // fragment shader

    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);

    glCompileShader(fragmentShader);

    // check for shader compile errors

    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);

    if (!success)

    {

        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);

        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;

    }

    // link shaders

    unsigned int shaderProgram = glCreateProgram();

    glAttachShader(shaderProgram, vertexShader);

    glAttachShader(shaderProgram, fragmentShader);

    glLinkProgram(shaderProgram);

    // check for linking errors

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

    // set up vertex data (and buffer(s)) and configure vertex attributes

    // ------------------------------------------------------------------

    float vertices[] = {

        -0.5f, -0.5f, 0.0f, // left  

         0.5f, -0.5f, 0.0f, // right

         0.0f,  0.5f, 0.0f  // top  

    };

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

    {

        // input

        // -----

        processInput(window);

        // render

        // ------

        glClearColor(0.2f, 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);

        // glBindVertexArray(0); // no need to unbind it every time

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)

        // -------------------------------------------------------------------------------

        glfwSwapBuffers(window);

        glfwPollEvents();

    }

    // optional: de-allocate all resources once they've outlived their purpose:

    // ------------------------------------------------------------------------

    glDeleteVertexArrays(1, &VAO);

    glDeleteBuffers(1, &VBO);

    glDeleteProgram(shaderProgram);

    // glfw: terminate, clearing all previously allocated GLFW resources.

    // ------------------------------------------------------------------

    glfwTerminate();

    return 0;

}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly

// ---------------------------------------------------------------------------------------------------------

void processInput(GLFWwindow *window)

{

    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)

        glfwSetWindowShouldClose(window, true);

}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes

// ---------------------------------------------------------------------------------------------

void framebuffer_size_callback(GLFWwindow* window, int width, int height)

{

    // make sure the viewport matches the new window dimensions; note that width and

    // height will be significantly larger than specified on retina displays.

    glViewport(0, 0, width, height);

}