C++实现延迟渲染（Deferred Shading）管线：内存带宽与G-Buffer优化

好的，以下是一篇关于C++实现延迟渲染管线，以及内存带宽与G-Buffer优化的技术讲座文章。

C++ 延迟渲染管线：内存带宽与 G-Buffer 优化

大家好，今天我们要深入探讨延迟渲染（Deferred Shading）管线及其优化，重点关注内存带宽和 G-Buffer 的设计。延迟渲染是一种强大的渲染技术，尤其适用于处理大量光源的场景。但它也带来了显著的内存带宽压力，需要我们精心设计和优化 G-Buffer 以提升性能。

1. 延迟渲染的基本概念

传统的正向渲染（Forward Rendering）对每个像素应用所有光源的影响，这对于复杂场景来说计算量巨大。延迟渲染将光照计算推迟到几何阶段之后，将场景的几何信息（位置、法线、材质属性等）存储在一个中间缓冲区，称为 G-Buffer。然后，对屏幕上的每个像素进行光照计算，只需要访问 G-Buffer 中的信息即可。

延迟渲染的步骤：

1. 几何阶段 (Geometry Pass)： 渲染场景，并将必要的信息写入 G-Buffer。G-Buffer 通常包含：

   • 位置 (Position)
   • 法线 (Normal)
   • 漫反射颜色 (Diffuse Color) / 反照率 (Albedo)
   • 镜面反射颜色 (Specular Color) / 光泽度 (Shininess/Roughness)
   • 深度 (Depth)

2. 光照阶段 (Lighting Pass)： 遍历屏幕上的每个像素，从 G-Buffer 中读取信息，计算光照，并将结果写入最终的颜色缓冲区。

延迟渲染的优势：

• 光照复杂度与几何复杂度解耦： 光照计算的复杂度不再依赖于场景的几何复杂度，而是依赖于屏幕分辨率和光源数量。
• 易于处理大量光源： 对于每个像素，我们只需要计算一次光照，避免了正向渲染中每个光源都要对每个像素进行计算的问题。
• 支持更复杂的光照模型： 由于光照计算是在屏幕空间进行的，我们可以使用更复杂的光照模型，而不用担心几何复杂度的影响。

延迟渲染的劣势：

• 更高的内存带宽需求： 需要读写 G-Buffer，增加了内存带宽的压力。
• 透明度处理复杂： 延迟渲染本身不直接支持透明度，需要额外的处理。
• 占用更多的显存： G-Buffer 会占用大量的显存。

2. G-Buffer 的设计与优化

G-Buffer 的设计是延迟渲染性能的关键。我们需要仔细权衡存储的信息、数据类型和格式，以最小化内存带宽和显存占用。

2.1 G-Buffer 的内容

G-Buffer 包含哪些信息取决于渲染的需求。以下是一些常见的 G-Buffer 内容及其考虑因素：

数据	描述	数据类型	考虑因素
位置 (Position)	世界空间中的像素位置	float3/half3	位置信息对于计算光照至关重要。 使用 float3 提供最高的精度，但会占用更多的内存。如果场景范围有限，可以使用 half3 甚至压缩格式。也可以将位置信息存储在深度缓冲中，并在光照阶段重建。
法线 (Normal)	世界空间中的像素法线	float3/half3	法线信息对于计算光照至关重要。 法线通常是单位向量，可以使用 half3 或压缩格式（例如，将法线向量存储在两个分量中，然后重建第三个分量）来减少内存占用。需要考虑法线的精度需求，特别是对于平滑表面，可能需要更高的精度。
反照率 (Albedo)	漫反射颜色	float3/unorm8x4	反照率决定了表面的基本颜色。 可以使用 float3 或 unorm8x4 (RGBA8) 格式。 unorm8x4 虽然精度较低，但可以节省内存。通常会将反照率存储在纹理中，并在几何阶段进行采样。
镜面反射 (Specular)	镜面反射颜色和光泽度	float3 + float / unorm8x4	镜面反射颜色和光泽度决定了表面的光泽程度。 可以使用 float3 存储颜色，float 存储光泽度，或者将它们打包到 unorm8x4 格式中。光泽度通常使用 Phong 指数或 roughness 值来表示。
深度 (Depth)	像素的深度值	float/uint	深度值用于重建世界空间位置，并进行深度测试。 深度值通常存储在单独的深度缓冲区中，但也可以将其存储在 G-Buffer 中。
物体ID (ObjectID)	物体的唯一ID， 用于后期处理或者选择物体。	uint	如果需要对特定物体进行操作，则需要保存物体的ID。

2.2 数据类型和格式的选择

选择合适的数据类型和格式可以显著减少 G-Buffer 的大小，从而降低内存带宽的需求。

• 浮点数精度： 使用 float (32位) 提供最高的精度，但会占用更多的内存。可以使用 half (16位) 或甚至 fixed (通常是 11位) 来降低内存占用。选择哪种精度取决于场景的需求。对于法线和位置等数据，可以使用 half，而对于颜色数据，可以使用 fixed 或 unorm8。
• 压缩格式： 可以使用压缩格式来存储法线和颜色数据。例如，可以使用 Octahedral Normal Vector Encoding 来压缩法线向量。对于颜色数据，可以使用 DXT 或 ETC 等纹理压缩格式。
• 数据打包： 可以将多个数据打包到单个纹理中。例如，可以将镜面反射颜色和光泽度打包到 RGBA 纹理中。

2.3 G-Buffer 的实现

以下是一个简单的 G-Buffer 实现的示例，使用 OpenGL 和 C++：

#include <iostream>
#include <vector>

#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>

class GBuffer {
public:
    GBuffer(int width, int height) : width(width), height(height) {}

    bool init() {
        // 1. 创建 Framebuffer
        glGenFramebuffers(1, &fbo);
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);

        // 2. 创建 G-Buffer 纹理
        glGenTextures(GBUFFER_NUM_TEXTURES, textures);

        // 位置纹理
        glBindTexture(GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_POSITION]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
        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, textures[GBUFFER_TEXTURE_TYPE_POSITION], 0);

        // 法线纹理
        glBindTexture(GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_NORMAL]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
        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_ATTACHMENT1, GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_NORMAL], 0);

        // 反照率 (Albedo) 纹理
        glBindTexture(GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_ALBEDO]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
        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_ATTACHMENT2, GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_ALBEDO], 0);

       // 镜面反射纹理
        glBindTexture(GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_SPECULAR]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
        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_ATTACHMENT3, GL_TEXTURE_2D, textures[GBUFFER_TEXTURE_TYPE_SPECULAR], 0);

        // 3. 创建 Depth Buffer
        glGenRenderbuffers(1, &depthBuffer);
        glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);

        // 4. 指定绘制的颜色缓冲
        GLenum attachments[GBUFFER_NUM_TEXTURES] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3};
        glDrawBuffers(GBUFFER_NUM_TEXTURES, attachments);

        // 5. 检查 Framebuffer 是否完整
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
            std::cerr << "Framebuffer not complete!" << std::endl;
            return false;
        }

        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        return true;
    }

    void bindForWriting() {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
    }

    void bindForReading() {
        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
        for (unsigned int i = 0; i < GBUFFER_NUM_TEXTURES; i++)
        {
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_2D, textures[i]);
        }
    }

    GLuint getTexture(GBUFFER_TEXTURE_TYPE TextureType)
    {
        return textures[TextureType];
    }

    ~GBuffer() {
        glDeleteFramebuffers(1, &fbo);
        glDeleteTextures(GBUFFER_NUM_TEXTURES, textures);
        glDeleteRenderbuffers(1, &depthBuffer);
    }

private:
    GLuint fbo;
    GLuint textures[GBUFFER_NUM_TEXTURES];
    GLuint depthBuffer;
    int width, height;

    enum {
        GBUFFER_TEXTURE_TYPE_POSITION,
        GBUFFER_TEXTURE_TYPE_NORMAL,
        GBUFFER_TEXTURE_TYPE_ALBEDO,
        GBUFFER_TEXTURE_TYPE_SPECULAR,
        GBUFFER_NUM_TEXTURES
    };

public:
    enum GBUFFER_TEXTURE_TYPE {
        GBUFFER_TEXTURE_TYPE_POSITION = 0,
        GBUFFER_TEXTURE_TYPE_NORMAL,
        GBUFFER_TEXTURE_TYPE_ALBEDO,
        GBUFFER_TEXTURE_TYPE_SPECULAR
    };
};

代码解释：

• GBuffer 类： 封装了 G-Buffer 的创建、绑定和销毁。
• init() 方法： 创建 Framebuffer、G-Buffer 纹理和 Depth Buffer。
  • glGenFramebuffers() 创建 Framebuffer 对象。
  • glGenTextures() 创建多个纹理对象，分别用于存储位置、法线和反照率。
  • glTexImage2D() 分配纹理内存，并指定纹理的格式和大小。
  • glFramebufferTexture2D() 将纹理附加到 Framebuffer 的颜色附件点。
  • glGenRenderbuffers() 创建 Renderbuffer 对象，用于存储深度信息。
  • glRenderbufferStorage() 分配 Renderbuffer 内存，并指定其格式和大小。
  • glFramebufferRenderbuffer() 将 Renderbuffer 附加到 Framebuffer 的深度附件点。
  • glDrawBuffers() 指定要绘制到的颜色附件点。
  • glCheckFramebufferStatus() 检查 Framebuffer 是否完整。
• bindForWriting() 方法： 绑定 Framebuffer 以进行写入操作。
• bindForReading() 方法： 绑定 Framebuffer 以进行读取操作，并激活相应的纹理单元。
• 枚举类型: 定义了纹理的类型，方便管理G-Buffer。

使用示例：

// 初始化 GLFW 和 GLEW

GLFWwindow* window;
int width = 800;
int height = 600;

// 创建 G-Buffer
GBuffer gBuffer(width, height);
if (!gBuffer.init()) {
    std::cerr << "Failed to initialize G-Buffer!" << std::endl;
    return -1;
}

// 几何阶段
gBuffer.bindForWriting();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// 渲染场景到 G-Buffer (使用相应的 Shader)
// ...

// 光照阶段
glBindFramebuffer(GL_FRAMEBUFFER, 0); // 绑定默认的 Framebuffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gBuffer.bindForReading();

// 使用 G-Buffer 中的数据进行光照计算 (使用相应的 Shader)
// ...

glfwSwapBuffers(window);

代码解释：

1. 创建窗口并初始化OpenGL上下文。
2. 创建 GBuffer 对象，并调用 init() 方法初始化 G-Buffer。
3. 在几何阶段，调用 gBuffer.bindForWriting() 绑定 G-Buffer，然后渲染场景。在渲染场景时，需要使用一个 Shader，将位置、法线和反照率等信息写入 G-Buffer 的纹理中。
4. 在光照阶段，调用 gBuffer.bindForReading() 绑定 G-Buffer，然后使用 G-Buffer 中的数据进行光照计算。在光照计算时，需要使用另一个 Shader，从 G-Buffer 的纹理中读取位置、法线和反照率等信息，然后计算光照。
5. 交换缓冲区，显示渲染结果。

2.4 重建位置信息

位置信息通常占用 G-Buffer 中最大的空间。为了减少内存占用，我们可以不直接存储位置信息，而是从深度缓冲中重建位置信息。

方法：

1. 在几何阶段，将深度值写入深度缓冲区。
2. 在光照阶段，从深度缓冲区读取深度值。
3. 使用投影矩阵和视口信息，将深度值转换为世界空间坐标。

代码示例 (GLSL)：

// Vertex Shader
#version 450 core

layout (location = 0) in vec3 aPos;

uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;

out vec4 FragPosCS; // Clip Space Position

void main()
{
    FragPosCS = projection * view * model * vec4(aPos, 1.0);
    gl_Position = FragPosCS;
}

// Fragment Shader
#version 450 core

in vec4 FragPosCS;
out vec3 FragPosWS;

uniform mat4 inverseProjectionView;

void main() {
    // Clip Space to Normalized Device Coordinates
    vec3 ndcPos = vec3(FragPosCS.xy / FragPosCS.w, gl_FragCoord.z);

    // Normalized Device Coordinates to World Space
    vec4 fragPosWorld = inverseProjectionView * vec4(ndcPos, 1.0);
    FragPosWS = fragPosWorld.xyz / fragPosWorld.w;
}

• FragPosCS: 顶点着色器计算出的裁剪空间坐标。
• gl_FragCoord.z: 片段着色器内置变量，存储了片段的深度值（在 0 到 1 之间）。
• ndcPos: 将裁剪空间坐标转换为 NDC 坐标。
• inverseProjectionView: 投影视图矩阵的逆矩阵，用于将 NDC 坐标转换到世界坐标。

优点：

• 减少 G-Buffer 的大小。
• 降低内存带宽的需求。

缺点：

• 需要额外的计算来重建位置信息。
• 重建的位置信息的精度可能受到深度缓冲精度的限制。

3. 内存带宽的优化

延迟渲染的主要瓶颈之一是内存带宽。我们需要尽可能减少 G-Buffer 的读写操作，以提高性能。

3.1 减少 G-Buffer 的大小

如前所述，选择合适的数据类型和格式，以及重建位置信息，都可以减少 G-Buffer 的大小，从而降低内存带宽的需求。

3.2 缓存优化

G-Buffer 的读写操作通常是随机的，这会导致缓存失效。为了提高缓存命中率，可以尝试以下方法：

• 分块渲染 (Tiled Rendering)： 将屏幕分成小块，分别渲染每个块。这样可以提高缓存的局部性，减少缓存失效。
• 排序光源 (Light Culling)： 在光照阶段之前，对光源进行排序，只计算对当前像素有影响的光源。这样可以减少 G-Buffer 的读取次数。可以利用 Tile-Based Deferred Rendering (TBDR) 架构的特性，在片上内存中完成 light culling。

3.3 使用 GPU 性能分析工具

使用 GPU 性能分析工具（例如，NVIDIA Nsight Graphics、AMD Radeon GPU Profiler）可以帮助我们识别内存带宽瓶颈，并找到优化的方向。

4. 透明度处理

延迟渲染本身不直接支持透明度。处理透明度的一种常见方法是使用正向渲染。

方法：

1. 渲染不透明物体到 G-Buffer。
2. 渲染透明物体，使用正向渲染。
3. 将透明物体的颜色与 G-Buffer 中的颜色混合。

这种方法简单易行，但可能会导致排序问题。为了解决排序问题，可以使用 Order-Independent Transparency (OIT) 技术。

5. 代码示例：光照Pass

#version 450 core
out vec4 FragColor;

in vec2 TexCoords;

uniform sampler2D gPosition;
uniform sampler2D gNormal;
uniform sampler2D gAlbedo;
uniform sampler2D gSpecular;

uniform vec3 lightPos;
uniform vec3 lightColor;
uniform vec3 viewPos;

void main()
{
    // 从 G-Buffer 读取数据
    vec3 FragPos = texture(gPosition, TexCoords).rgb;
    vec3 Normal = texture(gNormal, TexCoords).rgb;
    vec3 Albedo = texture(gAlbedo, TexCoords).rgb;
    vec4 Specular = texture(gSpecular, TexCoords);
    float Shininess = Specular.a;
    vec3 SpecularColor = Specular.rgb;

    // 环境光
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;

    // 漫反射
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(lightPos - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = diff * lightColor;

    // 镜面反射
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 reflectDir = reflect(-lightDir, norm);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), Shininess);
    vec3 specular = SpecularColor * spec * lightColor;

    vec3 result = Albedo * (ambient + diffuse + specular);
    FragColor = vec4(result, 1.0);
}

代码解释:

1. 从G-Buffer中读取位置，法线，反照率，镜面反射数据。
2. 计算环境光，漫反射和镜面反射。
3. 将各个光照分量相加，得到最终的颜色。

6.延迟渲染的优点和缺点总结

优点：

• 可以高效地处理大量光源。
• 光照计算与几何复杂度解耦。
• 方便实现复杂的光照效果。

缺点：

• 需要更多的内存带宽。
• 需要占用更多的显存。
• 处理透明度比较复杂。

内存带宽与G-Buffer的优化要点

通过对G-Buffer进行合理设计，比如降低浮点数精度，使用数据压缩等方法，可以有效的降低对内存带宽的需求，从而提高渲染效率。

希望今天的讲座对大家有所帮助。谢谢！

更多IT精英技术系列讲座，到智猿学院