OpenGL基础操作-绘制点

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <iostream>

using namespace std;

constexpr auto numVAOs = 1;

GLuint renderingProgram;
GLuint vao[numVAOs];

void printShaderLog(GLuint shader) {
    int len = 0;
    int chWrittn = 0;
    char *log;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
    if (len > 0) {
        log = (char*)malloc(len);
        glGetShaderInfoLog(shader, len, &chWrittn, log);
        cout << "Shader Info Log: " << log << endl;
        free(log);
    }
}

void printProgramLog(int prog) {
    int len = 0;
    int chWrittn = 0;
    char *log;
    glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &len);
    if (len > 0) {
        log = (char*)malloc(len);
        glGetProgramInfoLog(prog, len, &chWrittn, log);
        cout << "Program Info Log: " << log << endl;
        free(log);
    }
}

bool checkOpenGLError() {
    bool foundError = false;
    int glErr = glGetError();
    while (glErr != GL_NO_ERROR) {
        cout << "glError: " << glErr << endl;
        foundError = true;
        glErr = glGetError();
    }
    return foundError;
}

GLuint createShaderProgram() {
    GLint vertCompiled;
    GLint fragCompiled;
    GLint linked;

    const char* vshaderSource = 
        "#version 430 \n"
        "void main(void) \n"
        "{ gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";

    const char* fshaderSource = 
        "#version 430 \n"
        "out vec4 color; \n"
        "void main(void) \n"
        "{ if(gl_FragCoord.x < 200) color = vec4(1.0f, 0.0f, 0.0f, 1.0f);else color = vec4(0.0, 0.0, 1.0, 1.0);}";

    /**
     * @brief 创建着色器，返回一个整数ID作为索引号，便于后续引用
     * OpenGL中要使用一个shader需要如下几步：
     *    1.使用glCreateShader()方法创建一个空的着色器对象，用来接收源代码并进行编译
     *    2.使用glShaderSource()方法将着色器源码传递给着色器对象，以便保留该源代码的副本
     *    3.使用glCompileShader()方法对着色器对象中包含的任何源代码进行编译
     *    4.使用glCreateProgram()方法创建一个着色器程序，我们可以将着色器对象附加到该对象
     *    5.使用glAttachShader()方法将着色器附加到着色器程序
     *    6.使用glLinkProgram()方法将所有附加到程序对象的着色器对象链接在一起
     *    7.使用glDeleteShader()方法删除着色器对象。一旦着色器链接到一个程序对象，程序将包含二进制代码，不再需要着色器了　　
    **/
    GLuint vShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fShader = glCreateShader(GL_FRAGMENT_SHADER);

    /**
     * @brief 创建程序对象，返回整数ID索引值
    **/
    GLuint vfProgram = glCreateProgram();

    /**
     * @brief 将GLSL代码从字符串载入空着色器对象中
    **/
    glShaderSource(vShader, 1, &vshaderSource, NULL);
    glShaderSource(fShader, 1, &fshaderSource, NULL);

    /**
     * @brief 编译着色器
    **/
    glCompileShader(vShader);
    checkOpenGLError();
    glGetShaderiv(vShader, GL_COMPILE_STATUS, &vertCompiled);
    if (vertCompiled != 1) {
        cout << "vertex compilation failed" << endl;
        printShaderLog(vShader);
    }

    glCompileShader(fShader);
    checkOpenGLError();
    glGetShaderiv(fShader, GL_COMPILE_STATUS, &fragCompiled);
    if (fragCompiled != 1) {
        cout << "fragment compilation failed" << endl;
        printShaderLog(fShader);
    }
    

    /**
     * @brief 将着色器附加到程序对象
    **/
    glAttachShader(vfProgram, vShader);
    glAttachShader(vfProgram, fShader);
    glLinkProgram(vfProgram);
    checkOpenGLError();
    glGetProgramiv(vfProgram, GL_LINK_STATUS, &linked);
    if (linked != 1) {
        cout << "linked failed" << endl;
        printProgramLog(vfProgram);
    }

    glDeleteShader(vShader);
    glDeleteShader(fShader);

    return vfProgram;
}



void init(GLFWwindow* window) {
    renderingProgram = createShaderProgram();
    glGenVertexArrays(numVAOs, vao);
    glBindVertexArray(vao[0]);
}

void display(GLFWwindow* window, double currentTime) {

    /**
     * @brief OpenGL函数，用于指定颜色缓存区清除后填充的颜色值
    **/
    //glClearColor(1.0, 0.0, 0.0, 1.0);

    /**
     * @brief OpenGL函数，用指定的颜色清除（填充）颜色缓存区
    **/
    //glClear(GL_COLOR_BUFFER_BIT);

    /**
     * @brief 将含有已编译着色器的程序载入OpenGL管线阶段（GPU），并没有运行着色器，只是载入。
    **/
    glUseProgram(renderingProgram);


    glPointSize(400.0f);
    glDrawArrays(GL_POINTS, 0, 1);
}

int main(void) {

    /**
     * @brief 初始化glfw库
    **/
    if (!glfwInit()) { exit(EXIT_FAILURE); }

    /**
     * @brief 为glfwCreateWindow设置可选项
    **/
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    /**
     * @brief 创建glfw窗口及其相关的OpenGL上下文
    **/
    GLFWwindow* window = glfwCreateWindow(600, 600, "OpenGL", NULL, NULL);

    /**
     * @brief 创建glfw窗口及其相关的OpenGL上下文之后，并不会将它们自动关联，需要调用函数glfwMakeContextCurrent
    **/
    glfwMakeContextCurrent(window);

    /**
     * @brief 初始化glew库
    **/
    if (glewInit() != GLEW_OK) { exit(EXIT_FAILURE); }

    /**
     * @brief 开启垂直同步
    **/
    glfwSwapInterval(1);

    init(window);

    while (!glfwWindowShouldClose(window)) {

        /**
         * @brief glfwGetTime返回glfw初始化之后经过的时间
        **/
        display(window, glfwGetTime());

        /**
         * @brief 交换缓存内容，绘制屏幕
        **/
        glfwSwapBuffers(window);

        /**
         * @brief 处理窗口相关的事件
        **/
        glfwPollEvents();
    }

    /**
     * @brief 退出循环后，表示窗口关闭，需要销毁glfw窗口对象，终止程序运行
    **/
    glfwDestroyWindow(window);
    glfwTerminate();

    exit(EXIT_SUCCESS);
    return 0;
}