检测OpenGL和GLSL错误

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

using namespace std;

const int numVAOs = 1;
GLuint renderingProgram;
GLuint vao[numVAOs];

// 当 GLSL 代码编译失败时，显示 OpenGL 日志内容。
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);
    }
}

// 当 GLSL 链接失败时，显示 OpenGL 日志内容
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);
    }
}
// 检查 OpenGL 错误标志，即是否发生 OpenGL 错误
bool checkOpenGLError() {
    bool foundError = false;
    int glErr = glGetError();
    while (glErr != GL_NO_ERROR) {
        cout << "glError: " << glErr << endl;
        foundError = true;
        glErr = glGetError();
    }
    return foundError;
}


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

    // 定义定点着色器源码
    const char* vshaderSource =
        // 声明着色器版本，与OpenGL版本同步
        "#version 430 \n"    
        // 在顶点着色器，给 gl_Position指定out标签不是必需的，因为 gl_Position 是预定义的输出变量
        //"out vec4 gl_Position; \n"
        // main函数
        "void main(void) \n"    
        // 用内置变量gl_Position在源码中硬编码一个顶点位置
        "{ gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";   

    // 定义片段着色器源码
    const char* fshaderSource =
        // 声明着色器版本，与OpenGL版本同步
        "#version 430 \n"     
        // out 标签表明color变量是输出变量
        "out vec4 color; \n"
        // main函数
        "void main(void) \n"    
        // 设置颜色分量（rgba）
        "{ if (gl_FragCoord.x < 295) color = vec4(0.0, 1.0, 0.0, 1.0); else color = vec4(0.0, 0.0, 1.0, 1.0);}";         

    // 创建顶点着色器
    GLuint vShader = glCreateShader(GL_VERTEX_SHADER);
    // 创建片段着色器
    GLuint fShader = glCreateShader(GL_FRAGMENT_SHADER);
    // 载入顶点着色器源码
    glShaderSource(vShader, 1, &vshaderSource, nullptr);
    // 载入片段着色器源码
    glShaderSource(fShader, 1, &fshaderSource, nullptr);
    // 编译顶点着色器
    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);
    }
    // 创建程序对象，OpenGL程序对象包含一系列编译过的着色器
    GLuint vfProgram = glCreateProgram();
    // 加入顶点着色器
    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();
    // 当准备将数据集发送给管线时，数据集是以缓冲区形式发送的。这些缓冲区最后都会被存入顶点数组对象
    // 此案例我们在顶点着色器中硬编码一个点，因此不需要缓存区
    // 即使如此，OpenGL依然需要创建一个VAO
    glGenVertexArrays(numVAOs, vao);
    glBindVertexArray(vao[0]);
}

void display(GLFWwindow* window, double currentTime)
{
    // 指定颜色缓冲区清除后填充的值
    glClearColor(1.0, 0.0, 0.0, 1.0);
    // 用指定颜色清除（填充）颜色缓存区
    glClear(GL_COLOR_BUFFER_BIT);
    // 将含有两个已编译着色器的程序载入OpenGL管线阶段，并没有运行着色器
    glUseProgram(renderingProgram);
    // 设置绘制点的大小，便于观察
    glPointSize(50);
    // 启动管线处理过程，开始绘制
    glDrawArrays(GL_POINTS, 0, 1);
}

int main(void)
{
    // 如果glfw初始化失败则返回
    if (!glfwInit()) { exit(EXIT_FAILURE); }
    // 设置OpenGL程序的主版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    // 设置OpenGL程序的副版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    // 借助GLFW创建一个窗口
    GLFWwindow* window = glfwCreateWindow(600, 600, "Graphics Program With OpenGL", nullptr, nullptr);
    // 将GLFW创建的窗口与当前OpenGL的上下文关联起来
    glfwMakeContextCurrent(window);
    // 如果glew初始化失败则返回,glew负责调用OpenGL相关的函数
    if (glewInit() != GLEW_OK) { exit(EXIT_FAILURE); }
    // 交换间隔指示了直到交换缓冲区前需要等待多少帧，通常被理解为垂直同步。
    // 默认情况下，交换间隔为0，意味着缓冲区交换会立即发生。
    // 在一些快速的机器上，因为屏幕保持以典型的60 - 75次每秒的速度更新，许多帧会永远看不到，所以这会浪费许多CPU和GPU周期。
    // 而且，因为缓冲区可能会在屏幕更新的中途被交换，导致画面撕裂。
    // 因此，应用需要代表性地设置交换间隔为1。
    glfwSwapInterval(1);

    init(window);

    // 当用户点击关闭窗口按钮时会返回true
    while (!glfwWindowShouldClose(window))
    {
        display(window, glfwGetTime()); 
        // GLFW默认使用了双缓冲技术。这意味着每个窗口会有两个渲染缓冲区，一个前置缓冲区和一个后置缓冲区。
        // 前置缓冲区会在屏幕上显示而后置缓冲区是你渲染的目标。
        // 当整个帧已经渲染完毕时，两个缓冲区需要进行交换，所以后置缓冲区会变成前置缓冲区，反之亦然。
        glfwSwapBuffers(window);
        // 处理窗口相关事件
        glfwPollEvents();
    }
    // 销毁窗口
    glfwDestroyWindow(window);
    // 终止运行
    glfwTerminate();

    exit(EXIT_SUCCESS);
}