【C++游戏引擎开发】第17篇：OpenGL 延迟渲染(G-Buffer)

JuicyActiveGilbert

于 2025-04-18 10:02:49 发布

阅读量921

点赞数 26

分类专栏： C++游戏引擎开发知识点文章标签： c++ 游戏引擎开发语言

本文链接：https://blog.csdn.net/JuicyActiveGilbert/article/details/147307373

版权

OpenGL 中的延迟渲染（Deferred Rendering）是一种优化复杂光照场景的渲染技术，尤其适用于包含大量动态光源和复杂材质的场景。它与传统正向渲染（Forward Rendering）的核心区别在于：延迟渲染将几何计算与光照计算分离，通过多阶段渲染显著降低性能开销。

G-Buffer（Geometry Buffer，几何缓冲区）是延迟渲染（Deferred Rendering）中的核心组件，用于存储场景的几何和材质信息。它通过多渲染目标（MRT）技术将多个属性（如位置、法线、颜色、材质参数等）一次性写入不同的纹理中，后续光照阶段直接基于这些纹理数据进行计算，从而将几何处理与光照解耦，大幅提升复杂光照场景的效率。

一、 G-Buffer 通道及其作用

G-Buffer 通常包含多个纹理（Render Target），每个纹理存储特定类型的几何或材质数据。

1.1 位置（Position）

数据：片段的世界空间坐标（World Space Position）。
格式：RGB32F（高精度浮点纹理）。
作用：用于计算光照方向（如光源到片段的向量）和距离衰减。
优化：某些实现会改用视图空间（View Space）坐标，避免存储冗余的世界坐标。

1.2 法线（Normal）

数据：片段的法线向量，通常归一化后存储。
格式：RGB16F 或 RGB8_SNORM（有符号归一化）。
优化：
- 压缩编码：法线向量可以通过球坐标（Spherical Coordinates）或 八面体映射（Octahedral Encoding）压缩为 2 个通道（如 RG16F），节省带宽。
- 重建示例：

// 八面体映射解码（将 2D 向量还原为 3D 法线）
vec3 decodeNormal(vec2 encoded) {
   
    vec3 n = vec3(encoded, 1.0 - abs(encoded.x) - abs(encoded.y));
    float t = clamp(-n.z, 0.0, 1.0);
    n.xy += (n.xy >= 0.0) ? -t : t;
    return normalize(n);
}

1.3 漫反射颜色（Albedo）

数据：表面的基础颜色（Base Color），通常为 sRGB 空间的 RGB 值。
格式：RGB8（8 位无符号归一化纹理）。
注意：需确保颜色值未经光照影响（仅材质原始颜色）。

1.4 材质参数（Material Properties）

数据：包含金属度（Metallic）、粗糙度（Roughness）、环境光遮蔽（AO）等参数。
格式：RGBA8（每个参数占用一个通道）。
示例：R = 粗糙度，G = 金属度，B = AO，A = 其他（如透明度）。

1.5 深度（Depth）

数据：片段的深度值（通常存储在单独的深度缓冲中）。
格式：GL_DEPTH_COMPONENT24。
作用：
- 用于后期处理（如景深、SSAO）。
- 重建位置时，可结合深度和屏幕坐标反推世界坐标，避免直接存储位置（节省 G-Buffer 空间）。

二、G-Buffer 的创建与绑定

2.1 创建 G-Buffer 的纹理附件

// 创建 FBO
GLuint gBuffer;
glGenFramebuffers(1, &gBuffer);
glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);

// 位置纹理（RGB32F）
GLuint gPosition;
glGenTextures(1, &gPosition);
glBindTexture(GL_TEXTURE_2D, gPosition);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, height, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gPosition, 0);

// 法线纹理（RGB16F）
GLuint gNormal;
glGenTextures(1, &gNormal);
glBindTexture(GL_TEXTURE_2D, gNormal);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, NULL);
// ... 类似设置过滤方式并附加到 GL_COLOR_ATTACHMENT1

// 其他附件（Albedo、材质参数等）以此类推...

// 深度缓冲（可选，如果不需要后处理可省略）
GLuint rboDepth;
glGenRenderbuffers(1, &rboDepth);
glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth);

// 设置 MRT 输出目标
GLuint attachments[] = {
    GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 };
glDrawBuffers(3, attachments);

// 检查 FBO 完整性
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
   
    // 错误处理...
}

2.2 片段着色器中的 MRT 输出

在几何处理阶段，片段着色器需将数据写入多个颜色附件：

#version 330 core
layout (location = 0) out vec3 gPosition;    // 对应 GL_COLOR_ATTACHMENT0
layout (location = 1) out vec3 gNormal;      // 对应 GL_COLOR_ATTACHMENT1
layout (location = 2) out vec4 gAlbedoMetal;// 对应 GL_COLOR_ATTACHMENT2

void main() {
   
    gPosition = worldPos;
    gNormal = normalize(normal);
    gAlbedoMetal.rgb = texture(albedoMap, uv).rgb;
    gAlbedoMetal.a = metallic; // 金属度存储在 Alpha 通道
}

三、MRT（Multiple Render Targets，多渲染目标）详解

MRT（多渲染目标）是图形渲染中的核心技术，允许在单个渲染通道中将数据同时输出到多个缓冲区。它在延迟渲染（Deferred Rendering）、后处理（Post-Processing）和复杂材质系统中广泛应用，尤其适用于需要同时处理多种几何或材质属性的场景。

3.1 MRT 的核心概念

3.1.1 基本定义

MRT：允许片段着色器一次写入多个颜色缓冲区的技术。
核心作用：将多个属性（如位置、法线、颜色、材质参数等）一次性存储到不同的纹理中，供后续渲染阶段使用。

3.1.2 典型应用场景

延迟渲染：在几何处理阶段将数据写入 G-Buffer（位置、法线、颜色等）。
后处理：同时输出多个中间结果（如亮度、深度、法线等）。
材质混合：分离不同材质属性（如金属度、粗糙度、透明度）。

3.2 MRT 的实现流程

3.2.1 创建帧缓冲对象（FBO）

MRT 需要依赖 FBO 来管理多个渲染目标：

GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);

3.2.2 定义多个颜色附件

每个颜色附件对应一个纹理，用于存储特定数据：

// 创建位置纹理（RGB32F）
GLuint texPosition;
glGenTextures(1, &texPosition);
glBindTexture(GL_TEXTURE_2D, texPosition);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, height, 0, GL_RGB, GL_FLOAT, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texPosition, 0);

// 创建法线纹理（RGB16F）
GLuint texNormal;
glGenTextures(1, &texNormal);
glBindTexture(GL_TEXTURE_2D, texNormal);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, texNormal, 0);

// 创建颜色纹理（RGB8）
GLuint texAlbedo;
glGenTextures(1, &texAlbedo);
glBindTexture(GL_TEXTURE_2D, texAlbedo);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, texAlbedo, 0);

3.2.3 绑定颜色附件到 FBO

通过 glDrawBuffers 指定片段着色器输出的目标：

GLenum attachments[] = {
   
    GL_COLOR_ATTACHMENT0,  // 对应 texPosition
    GL_COLOR_ATTACHMENT1,  // 对应 texNormal
    GL_COLOR_ATTACHMENT2   // 对应 texAlbedo
};
glDrawBuffers(3, attachments);

3.2.4 片段着色器配置

在着色器中通过 layout(location = N) 指定输出到不同颜色附件：

#version 330 core
layout (location = 0) out vec3 outPosition;  // 写入 GL_COLOR_ATTACHMENT0
layout (location = 1) out vec3 outNormal;    // 写入 GL_COLOR_ATTACHMENT1
layout (location = 2) out vec3 outAlbedo;    // 写入 GL_COLOR_ATTACHMENT2

void main() {
   
    outPosition = worldPos;     // 位置数据
    outNormal = normalize(normal); // 法线数据
    outAlbedo = texture(albedoMap, uv).rgb; // 颜色数据
}

四、实战示例

4.1 MRT示例

// 引入必要的头文件
#include <glad/glad.h>          // GLAD库，用于管理OpenGL函数指针
#include <GLFW/glfw3.h>         // GLFW库，用于窗口和输入管理
#include <glm/glm.hpp>          // GLM数学库（虽然代码中未实际使用）
#include <iostream>             // 标准输入输出流
#include <vector>               // 标准向量容器

// 窗口设置
const unsigned int SCR_WIDTH = 800;   // 屏幕宽度
const unsigned int SCR_HEIGHT = 600;  // 屏幕高度
GLFWwindow* window = nullptr;         // GLFW窗口指针

// 顶点数据（两个三角形组成正方形，包含位置、颜色和纹理坐标）
const float quadVertices[] = {
   
    // 位置          // 颜色           // 纹理坐标
    -0.5f,  0.5f,   1.0f, 0.0f, 0.0f,   0.0f, 1.0f,  // 左上
    -0.5f, -0.5f,   0.0f, 1.0f, 0.0f,   0.0f, 0.0f,  // 左下
     0.5f, -0.5f,   0.0f, 0.0f, 1.0f,   1.0f, 0.0f,  // 右下

    -0.5f,  0.5f,   1.0f, 0.0f, 0.0f,   0.0f, 1.0f,  // 左上（重复第一个三角形的两个顶点）
     0.5f, -0.5f,   0.0f, 0.0f, 1.0f,   1.0f, 0.0f,  // 右下
     0.5f,  0.5f,   1.0f, 1.0f, 0.0f,   1.0f, 1.0f   // 右上
};

// 顶点着色器源码（硬编码）
const char* vertexShaderSource = R"(
#version 460 core
layout (location = 0) in vec2 aPos;        // 位置属性，位置0
layout (location = 1) in vec3 aColor;      // 颜色属性，位置1
layout (location = 2) in vec2 aTexCoord;   // 纹理坐标属性，位置2

out vec3 Color;         // 输出颜色到片段着色器
out vec2 TexCoord;      // 输出纹理坐标到片段着色器

void main() {
    gl_Position = vec4(aPos, 0.0, 1.0);  // 设置顶点位置，z设为0.0，w设为1.0
    Color = aColor;                       // 传递颜色
    TexCoord = aTexCoord;                 // 传递纹理坐标
}
)";

// 片段着色器源码（多渲染目标输出）
const char* fragmentShaderSource = R"(
#version 460 core
in vec3 Color;       // 输入颜色
in vec2 TexCoord;    // 输入纹理坐标

// 定义三个渲染目标输出
layout (location = 0) out vec4 FragColor;    // 第一个输出：常规颜色
layout (location = 1) out vec4 Brightness;   // 第二个输出：亮度信息
layout (location = 2) out vec4 PositionData; // 第三个输出：位置数据

uniform float time;  // 时间统一变量，用于动态效果

void main() {
    // 第一个目标：随时间变化的颜色（使用sin函数产生波动效果）
    FragColor = vec4(Color * (0.5 + 0.5*sin(time)), 1.0);
    
    // 第二个目标：计算亮度（使用RGB转亮度的标准公式）
    float brightness = dot(FragColor.rgb, vec3(0.2126, 0.7152, 0.0722));
    Brightness = vec4(vec3(brightness), 1.0);
    
    // 第三个目标：位置数据（纹理坐标和时间组合）
    PositionData = vec4(TexCoord, sin(time) * 0.5 + 0.5, 1.0);
}
)";

// 初始化GLFW窗口
void initGLFW() {
   
    if (!glfwInit()) {
     // 初始化GLFW库
        std::cerr << "Failed to initialize GLFW" << std::endl;
        exit(EXIT_FAILURE);
    }

    // 配置GLFW窗口属性
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);      // 主版本号4
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);      // 次版本号6
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 使用核心模式

    // 创建窗口对象
    window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "MRT Demo", nullptr