图形渲染与 Shader / 系统课时

封装着色器程序

封装着色器程序

这一节把分散的着色器读取、编译、链接和 Uniform 设置收拢到一个可复用类中。完成后,调用方只需要创建程序对象、激活程序并设置参数,同时能在编译或链接失败时拿到清晰日志。

学习目标

  • 明确着色器类应该持有和释放哪些 OpenGL 对象
  • 实现源码加载、编译、链接与错误检查
  • 用统一接口激活程序并设置常用 Uniform

设计职责边界

一个实用的 ShaderProgram 不应该负责网格、纹理或绘制循环,它只管理“从源码到可用 Program”的生命周期。长期持有的是链接后的 Program Object;顶点、片段 Shader Object 只在链接阶段存在,链接成功后即可删除。

构造阶段最适合完成读取、编译和链接,因为对象一旦构造成功,就应该处于可用状态。任何一步失败都直接抛出包含 OpenGL 日志的异常,避免留下“对象存在但程序不可用”的半成品状态。

ShaderProgram 统一管理源码、着色器对象、程序对象与 Uniform 的生命周期

建立可复用类

下面示例使用 GLFW 创建不可见 OpenGL 3.3 上下文,并用 GLAD 加载函数。程序会先写出两份最小 GLSL 文件,再由 ShaderProgram 从文件读取源码、编译并链接。工程需要已经可用的 GLFW 与 GLAD。

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

#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>

class ShaderProgram {
public:
    ShaderProgram(const std::string& vertexPath, const std::string& fragmentPath) {
        const std::string vertexSource = readFile(vertexPath);
        const std::string fragmentSource = readFile(fragmentPath);

        GLuint vertex = compile(GL_VERTEX_SHADER, vertexSource);
        GLuint fragment = 0;
        try {
            fragment = compile(GL_FRAGMENT_SHADER, fragmentSource);
        } catch (...) {
            glDeleteShader(vertex);
            throw;
        }

        id_ = glCreateProgram();
        glAttachShader(id_, vertex);
        glAttachShader(id_, fragment);
        glLinkProgram(id_);
        glDeleteShader(vertex);
        glDeleteShader(fragment);
        checkLink(id_);
    }

    ~ShaderProgram() {
        if (id_ != 0) {
            glDeleteProgram(id_);
        }
    }

    ShaderProgram(const ShaderProgram&) = delete;
    ShaderProgram& operator=(const ShaderProgram&) = delete;

    void use() const {
        glUseProgram(id_);
    }

    void setFloat(const std::string& name, float value) const {
        GLint location = glGetUniformLocation(id_, name.c_str());
        if (location < 0) {
            throw std::runtime_error("uniform not found: " + name);
        }
        glUniform1f(location, value);
    }

    void setVec4(const std::string& name, float x, float y, float z, float w) const {
        GLint location = glGetUniformLocation(id_, name.c_str());
        if (location < 0) {
            throw std::runtime_error("uniform not found: " + name);
        }
        glUniform4f(location, x, y, z, w);
    }

private:
    GLuint id_ = 0;

    static std::string readFile(const std::string& path) {
        std::ifstream input(path);
        if (!input) {
            throw std::runtime_error("cannot open shader file: " + path);
        }
        std::ostringstream buffer;
        buffer << input.rdbuf();
        return buffer.str();
    }

    static GLuint compile(GLenum type, const std::string& source) {
        GLuint shader = glCreateShader(type);
        const char* text = source.c_str();
        glShaderSource(shader, 1, &text, nullptr);
        glCompileShader(shader);

        GLint ok = GL_FALSE;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
        if (ok == GL_TRUE) {
            return shader;
        }

        char log[1024] = {};
        glGetShaderInfoLog(shader, sizeof(log), nullptr, log);
        glDeleteShader(shader);
        throw std::runtime_error(std::string("shader compile failed: ") + log);
    }

    static void checkLink(GLuint program) {
        GLint ok = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &ok);
        if (ok == GL_TRUE) {
            return;
        }

        char log[1024] = {};
        glGetProgramInfoLog(program, sizeof(log), nullptr, log);
        glDeleteProgram(program);
        throw std::runtime_error(std::string("program link failed: ") + log);
    }
};

int main() {
    std::ofstream("shader.vert") << R"(#version 330 core
layout(location = 0) in vec3 aPos;
uniform float offset;
void main() {
    gl_Position = vec4(aPos.x + offset, aPos.y, aPos.z, 1.0);
}
)";

    std::ofstream("shader.frag") << R"(#version 330 core
out vec4 FragColor;
uniform vec4 color;
void main() {
    FragColor = color;
}
)";

    if (!glfwInit()) {
        std::cerr << "GLFW init failed\n";
        return 1;
    }

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

    GLFWwindow* window = glfwCreateWindow(64, 64, "shader-test", nullptr, nullptr);
    if (!window) {
        glfwTerminate();
        std::cerr << "window creation failed\n";
        return 1;
    }

    glfwMakeContextCurrent(window);
    if (!gladLoadGLLoader(reinterpret_cast<GLADloadproc>(glfwGetProcAddress))) {
        glfwDestroyWindow(window);
        glfwTerminate();
        std::cerr << "GLAD load failed\n";
        return 1;
    }

    try {
        ShaderProgram shader("shader.vert", "shader.frag");
        shader.use();
        shader.setFloat("offset", 0.1f);
        shader.setVec4("color", 1.0f, 0.4f, 0.2f, 1.0f);
        std::cout << "shader program linked\nuniforms updated\n";
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
    }

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}

预期输出

text
shader program linked
uniforms updated

如果驱动拒绝某个 GLSL 版本或源码存在语法错误,正常结果不是这两行成功信息,而是异常中的真实编译或链接日志;不要用固定文本覆盖驱动返回的错误内容。

统一参数设置

glGetUniformLocation 只对当前链接结果有效,因此参数接口应绑定到同一个 Program。小型项目可以像示例一样每次按名称查询;更新频率很高时,可在链接完成后缓存 location,减少重复字符串查找。

设置 Uniform 前必须先 use()。如果名称拼错、Uniform 被优化掉或根本不存在,glGetUniformLocation 会返回 -1。封装层最好明确处理这个值,而不是让调用失败悄悄发生。

管好对象生命周期

Program Object 属于显式 OpenGL 资源,类析构时应调用 glDeleteProgram。同时禁止默认复制,可以避免两个 C++ 对象持有同一个 OpenGL 句柄后发生重复释放。

还要注意 OpenGL 删除调用依赖有效上下文:ShaderProgram 必须在对应上下文仍然存在时析构。真实引擎中通常让渲染资源先释放,再销毁窗口和 OpenGL Context;这样类的 RAII 语义才真正可靠。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

封装着色器程序

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通