ChernoOpenGL_Tutorial（2）：13~16

13. Abstracting OpenGL into Classes

这一节将封装一些代码。

对于cherno，一般而言，size 意味着 bytes 单位的，而 count 则往往是数量，即 element account。对于这里的 IndexBuffer 的封装，如果数量没有那么多或许也可以用比如 16 位的整数，但是这里我们简单地直接都用 32 位的整数，即常用的四字节的 int。

Render.h ：把之前处理错误部分的代码都封装了起来。

#pragma once

#include <GL/glew.h>

#define ASSERT(x) if (!(x)) __debugbreak(); // 前面的 __ 是 compiler intrinsic
#define GLCall(x) GLClearError();\
    x;\
    ASSERT(GLLogCall(#x, __FILE__, __LINE__))

void GLClearError();

bool GLLogCall(const char* function, const char* file, int line);

Render.cpp：

#include "Render.h"
#include <iostream>

void GLClearError()
{
    while (glGetError() != GL_NO_ERROR);
}

bool GLLogCall(const char* function, const char* file, int line)
{
    while (GLenum error = glGetError())
    {
        std::cout << "[OpenGL Error] (" << error << ")" << function <<
            " " << file << ":" << line << std::endl;
        return false;
    }
    return true;
}

VertexBuffer.h ：

#pragma once

class VertexBuffer
{
private:
	unsigned int m_RendererID;
public:
	VertexBuffer(const void* data, unsigned int size);
	~VertexBuffer();

	void Bind() const;
	void Unbind() const;
};

VertexBuffer.cpp：

#include "VertexBuffer.h"

#include "Render.h"

VertexBuffer::VertexBuffer(const void* data, unsigned int size)
{
    GLCall(glGenBuffers(1, &m_RendererID));
    GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID));
    GLCall(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW));
}

VertexBuffer::~VertexBuffer()
{
    GLCall(glDeleteBuffers(1, &m_RendererID));
}

void VertexBuffer::Bind() const
{
    glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
}

void VertexBuffer::Unbind() const
{
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

IndexBuffer.h：

#pragma once

class IndexBuffer
{
private:
	unsigned int m_RendererID;
	unsigned int m_Count; // 多少个 indices
public:
	IndexBuffer(const unsigned int* data, unsigned int count);
	~IndexBuffer();

	void Bind() const;
	void Unbind() const;

	inline unsigned int GetCount() const { return m_Count;  }
};

IndexBuffer.cpp：

#include "IndexBuffer.h"

#include "Render.h"

IndexBuffer::IndexBuffer(const unsigned int* data, unsigned int count)
    : m_Count(count)
{
    ASSERT(sizeof(unsigned int) == sizeof(GLuint));

    GLCall(glGenBuffers(1, &m_RendererID));
    GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID));
    GLCall(glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), data, GL_STATIC_DRAW));
}

IndexBuffer::~IndexBuffer()
{
    GLCall(glDeleteBuffers(1, &m_RendererID));
}

void IndexBuffer::Bind() const
{
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
}

void IndexBuffer::Unbind() const
{
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

最终的 Application.cpp ：

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream> // stringstream

#include "Render.h"

#include "VertexBuffer.h"
#include "IndexBuffer.h"

struct ShaderProgramSource
{
    std::string VertexSource;
    std::string FragmentSource;
};

static ShaderProgramSource ParseShader(const std::string& filepath)
{
    std::ifstream stream(filepath);

    enum class ShaderType
    {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    std::string line;
    std::stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (std::getline(stream, line))
    {
        if (line.find("#shader") != std::string::npos)
        {
            if (line.find("vertex") != std::string::npos)
            {
                type = ShaderType::VERTEX;
            }
            else if (line.find("fragment") != std::string::npos)
            {
                type = ShaderType::FRAGMENT;
            }
        }
        else
        {
            // 把 type 作为 string stream 的 index，更清晰
            ss[(int)type] << line << '\n';
        }
    }

    return { ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(unsigned int type, const std::string& source) // 第二个参数是因为 GLenum 是 unsigned int 的
{
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str(); // 返回的是一个指向 string 内部的指针，因此这个 string 必须存在才有效
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    // Error handling
    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result); // iv: integer, vector
    if (result == GL_FALSE)
    {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);

        // alloca 是C语言给你的一个函数，它让你在堆栈上动态地分配，根据你的判断来使用
        // 因为我们不想在堆上分配，所以调用了这个函数
        char* message = (char*)alloca(length * sizeof(char)); 
        glGetShaderInfoLog(id, length, &length, message);
        std::cout << "Failed to compile " << (type == GL_VERTEX_SHADER ? "vertex" : "fragment") << " shader!" << std::endl;
        std::cout << message << std::endl;
        glDeleteShader(id);
        return 0;
    }

    return id;
}

// 从文件中获取，然后编译、链接，生成buffer id，用于之后的绑定
static unsigned int CreateShader(const std::string& vertexShader, const std::string& fragmentShader)
{
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
    unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);

    // 查阅文档我们知道，验证的状态会被存储为程序对象状态的一部分你可以调用，比如用 glGetProgram 查询实际结果是什么之类的
    glValidateProgram(program);

    // 因为已经被链接到一个程序中了，所以如果你愿意可以删除中间部分
    // 在C++中编译东西的时候会得到诸如 .obj 这样的中间文件，shader 也是如此
    // 还有一些其他的函数，比如 glDetachShader 之类的它会删除源代码
    // 但是cherno不喜欢碰那些函数。
    // 首先清理这些也不是必要的，因为它占用的内存很少，但是保留着色器的源代码对于调试之类的是很重要的
    // 因此很多引擎根本不会去调用 glDetachShader 这些
    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glfwSwapInterval(5);

    if (glewInit() != GLEW_OK)
        std::cout << "Error!" << std::endl;

    std::cout << glGetString(GL_VERSION) << std::endl;

    {
        float positions[] = {
            -0.5f, -0.5f,
             0.5f, -0.5f,
             0.5f,  0.5f,
            -0.5f,  0.5f
        };

        // 必须用 unsigned
        unsigned int indices[] = {
            0, 1, 2,
            2, 3, 0
        };

        unsigned int vao;
        GLCall(glGenVertexArrays(1, &vao));
        GLCall(glBindVertexArray(vao));

        VertexBuffer vb(positions, 4 * 2 * sizeof(float));

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

        IndexBuffer ib(indices, 6);

        ShaderProgramSource source = ParseShader("res/shaders/Basic.shader");
        unsigned int shader = CreateShader(source.VertexSource, source.FragmentSource);
        glUseProgram(shader);

        GLCall(int location = glGetUniformLocation(shader, "u_Color"));
        ASSERT(location != -1)
            GLCall(glUniform4f(location, 0.2f, 0.3f, 0.8f, 1.0f));

        // 全部解绑
        GLCall(glBindVertexArray(0));
        GLCall(glUseProgram(0));
        GLCall(glBindBuffer(GL_ARRAY_BUFFER, 0));
        GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));

        float r = 0.0f;
        float increment = 0.05f;

        /* Loop until the user closes the window */
        while (!glfwWindowShouldClose(window))
        {
            /* Render here */
            glClear(GL_COLOR_BUFFER_BIT);

            // 绑定 shader 和 传递 uniform
            GLCall(glUseProgram(shader));
            GLCall(glUniform4f(location, r, 0.3f, 0.8f, 1.0f));

            // 绑定 VAO
            GLCall(glBindVertexArray(vao));
            ib.Bind();

            // 执行 drawcall
            GLCall(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));

            if (r > 1.0f)
                increment = -0.05f;
            else if (r < 0.0f)
                increment = 0.05f;

            r += increment;

            /* Swap front and back buffers */
            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }

        GLCall(glDeleteProgram(shader));
    }

    glfwTerminate();
    return 0;
}

可以看到最后用一个作用域包起来了。如果没有这样做，由于 VertexBuffer 和 IndexBuffer 都是在栈作用域的，最后调用 glfwTerminate 的时候结束了 OpenGL 上下文，但是这俩还没有释放。解决方法可以在堆上释放，结束上下文之前手动delete掉，也可以像上面这样用一个作用域包起来。否则会发生关闭窗口程序还在运行这样的不可描述的错误。

14. Buffer Layout Abstraction in OpenGL

比如做“拾取”功能，比如：https://zhuanlan.zhihu.com/p/350231869，那么就最好在 CPU 端也保存一份一样的 buffer 用来判定。

比如我们希望能封装成这样：

其实就是希望，之前的 vao 这一套都存在 OpenGL 端，即显存端。希望这里弄一个 CPU 端来对应。我是这样理解的。

因此这一节我们将接着封装代码，所有代码在这里：
https://github.com/hebohang/OpenGL_Cherno_Tutorial/tree/14_Buffer_Layout_Abstraction

15. Shader Abstraction in OpenGL

因为 shader 很重要，所以通常会打造一个更复杂更强大更容易使用的 shader 系统。在游戏引擎中很普遍的是自造一个 shading language （比如 unity 的 shaderlab 我想），并将这个代码转换成各个图形api、各个平台的 shader 代码。并且可以实时地进行一些扩展和控制。比如游戏引擎里面去生成一个新的 shader，它们甚至通常在游戏实际运行时直接被用于渲染。

那么 shader 需要什么？

1. 要有一个文件或者字符串可以符合shader语法被编译；
2. bind、unbind
3. 设置 shader 的 uniforms

在 class shader 中的 Set uniforms 步骤，我们写的是如 SetUniform4f 这样的函数而没有用函数模板，因为这是OpenGL系列，所以没有准备打造一个复杂的 shader 系统。

所有代码：
https://github.com/hebohang/OpenGL_Cherno_Tutorial/tree/15_Shader_Abstraction

16. Writing a Basic Renderer in OpenGL

unbind 在OpenGL里头不是那么必要。它在 debug 的时候很有用。基本上，unbind 在OpenGL里头是对性能的一种浪费。只要直接绑定别的就好了。

在这里我们的 draw 函数传入的是 vertex array、index buffer 和 shader，这有些奇怪，因为一般情况下我们不是传shader，而是材质material。

所谓材质material，其实就是 shader 加上一堆 data。比如 shader 加上它的 uniforms。不管它是 specific uniforms 还是 per object uniforms。比如这里我们的矩形颜色就像是一种 per object uniforms 。这将被存在 material 里面。这样传入 material 后，每次draw就会绑定shader，设置好所有的uniforms，然后drawcall（当然还有 vertex buffer index buffer 之类的）。

所有代码：
https://github.com/hebohang/OpenGL_Cherno_Tutorial/tree/16_Basic_Renderer