计算机图形学笔记(六)：现代图形学前沿#

主要是一些前沿技术

目录#

实时渲染优化技术 - LOD、遮挡剔除与GPU优化
基于物理的渲染(PBR) - 微表面理论与材质建模
体积渲染与参与介质 - 云雾烟尘的渲染技术
计算着色器与GPGPU - 并行计算在图形学中的应用

实时渲染优化技术#

25.1 层次细节(LOD)技术#

25.1.1 LOD的数学基础#

距离基础LOD： $LOD_{level} = \left\lfloor \log_2\left(\frac{distance}{base\_distance}\right) \right\rfloor$

其中：

$distance$ 是物体到相机的距离
$base\_distance$ 是基准距离
$LOD_{level}$ 是细节层次等级

屏幕空间误差度量： $error_{screen} = \frac{error_{world} \times focal\_length}{distance \times pixel\_size}$

25.1.2 几何LOD实现#

1
class GeometricLOD {
2
private:
3
    struct LODLevel {
4
        Mesh mesh;
5
        float distance_threshold;
6
        int triangle_count;
7
        float geometric_error;
8
    };
9

10
    std::vector<LODLevel> lod_levels;
11

12
public:
13
    void generate_lod_chain(const Mesh& original_mesh, int num_levels) {
14
        lod_levels.clear();
15
        lod_levels.resize(num_levels);
16

17
        // 原始网格作为LOD 0
18
        lod_levels[0] = {original_mesh, 0.0f,
19
                        original_mesh.triangle_count(), 0.0f};
20

21
        // 生成简化版本
22
        for (int i = 1; i < num_levels; ++i) {
23
            float reduction_ratio = std::pow(0.5f, i);
24
            lod_levels[i].mesh = simplify_mesh(original_mesh, reduction_ratio);
25
            lod_levels[i].distance_threshold = calculate_distance_threshold(i);
26
            lod_levels[i].triangle_count = lod_levels[i].mesh.triangle_count();
27
            lod_levels[i].geometric_error = calculate_geometric_error(
28
                original_mesh, lod_levels[i].mesh);
29
        }
30
    }
31

32
    const Mesh& select_lod(const Vector3f& camera_pos, const Vector3f& object_pos) {
33
        float distance = (camera_pos - object_pos).norm();
34

35
        for (int i = lod_levels.size() - 1; i >= 0; --i) {
36
            if (distance >= lod_levels[i].distance_threshold) {
37
                return lod_levels[i].mesh;
38
            }
39
        }
40

41
        return lod_levels[0].mesh;  // 最高细节
42
    }
43

44
private:
45
    Mesh simplify_mesh(const Mesh& mesh, float reduction_ratio) {
46
        // 使用二次误差度量进行网格简化
47
        QuadricErrorMetrics qem(mesh);
48
        return qem.simplify(reduction_ratio);
49
    }
50

51
    float calculate_distance_threshold(int lod_level) {
52
        // 基于屏幕空间误差的距离阈值
53
        float base_distance = 10.0f;
54
        return base_distance * std::pow(2.0f, lod_level);
55
    }
56

57
    float calculate_geometric_error(const Mesh& original, const Mesh& simplified) {
58
        // 计算Hausdorff距离作为几何误差
59
        float max_error = 0.0f;
60

61
        for (const auto& vertex : simplified.vertices) {
62
            float min_distance = std::numeric_limits<float>::max();
63

64
            for (const auto& orig_vertex : original.vertices) {
65
                float distance = (vertex.position - orig_vertex.position).norm();
66
                min_distance = std::min(min_distance, distance);
67
            }
68

69
            max_error = std::max(max_error, min_distance);
70
        }
71

72
        return max_error;
73
    }
74
};

25.2 遮挡剔除技术#

25.2.1 视锥体剔除#

平面方程： $ax + by + cz + d = 0$

点到平面距离： $distance = \frac{|ax_0 + by_0 + cz_0 + d|}{\sqrt{a^2 + b^2 + c^2}}$

1
class FrustumCuller {
2
private:
3
    struct Plane {
4
        Vector3f normal;
5
        float distance;
6

7
        float distance_to_point(const Vector3f& point) const {
8
            return normal.dot(point) + distance;
9
        }
10

11
        bool is_point_inside(const Vector3f& point) const {
12
            return distance_to_point(point) >= 0;
13
        }
14
    };
15

16
    std::array<Plane, 6> frustum_planes;  // 左右上下远近
17

18
public:
19
    void extract_frustum_planes(const Matrix4f& view_projection_matrix) {
20
        // 从MVP矩阵提取视锥体平面
21
        Matrix4f mvp = view_projection_matrix.transpose();
22

23
        // 左平面: mvp.row(3) + mvp.row(0)
24
        frustum_planes[0] = extract_plane(mvp.row(3) + mvp.row(0));
25

26
        // 右平面: mvp.row(3) - mvp.row(0)
27
        frustum_planes[1] = extract_plane(mvp.row(3) - mvp.row(0));
28

29
        // 下平面: mvp.row(3) + mvp.row(1)
30
        frustum_planes[2] = extract_plane(mvp.row(3) + mvp.row(1));
31

32
        // 上平面: mvp.row(3) - mvp.row(1)
33
        frustum_planes[3] = extract_plane(mvp.row(3) - mvp.row(1));
34

35
        // 近平面: mvp.row(3) + mvp.row(2)
36
        frustum_planes[4] = extract_plane(mvp.row(3) + mvp.row(2));
37

38
        // 远平面: mvp.row(3) - mvp.row(2)
39
        frustum_planes[5] = extract_plane(mvp.row(3) - mvp.row(2));
40
    }
41

42
    bool is_aabb_visible(const AABB& aabb) const {
43
        for (const auto& plane : frustum_planes) {
44
            // 计算AABB的正顶点（最远点）
45
            Vector3f positive_vertex = aabb.min;
46

47
            if (plane.normal.x() >= 0) positive_vertex.x() = aabb.max.x();
48
            if (plane.normal.y() >= 0) positive_vertex.y() = aabb.max.y();
49
            if (plane.normal.z() >= 0) positive_vertex.z() = aabb.max.z();
50

51
            // 如果正顶点在平面外侧，则AABB完全在视锥体外
52
            if (plane.distance_to_point(positive_vertex) < 0) {
53
                return false;
54
            }
55
        }
56

57
        return true;
58
    }
59

60
    bool is_sphere_visible(const Vector3f& center, float radius) const {
61
        for (const auto& plane : frustum_planes) {
62
            if (plane.distance_to_point(center) < -radius) {
63
                return false;
64
            }
65
        }
66

67
        return true;
68
    }
69

70
private:
71
    Plane extract_plane(const Vector4f& plane_coeffs) {
72
        Vector3f normal = plane_coeffs.head<3>();
73
        float length = normal.norm();
74

75
        return {normal / length, plane_coeffs.w() / length};
76
    }
77
};

25.2.2 遮挡查询#

1
class OcclusionCuller {
2
private:
3
    struct OcclusionQuery {
4
        GLuint query_id;
5
        bool result_available;
6
        GLuint sample_count;
7

8
        OcclusionQuery() {
9
            glGenQueries(1, &query_id);
10
            result_available = false;
11
            sample_count = 0;
12
        }
13

14
        ~OcclusionQuery() {
15
            glDeleteQueries(1, &query_id);
16
        }
17
    };
18

19
    std::unordered_map<uint32_t, std::unique_ptr<OcclusionQuery>> queries;
20

21
public:
22
    void begin_occlusion_test(uint32_t object_id) {
23
        auto& query = get_or_create_query(object_id);
24

25
        // 开始遮挡查询
26
        glBeginQuery(GL_SAMPLES_PASSED, query->query_id);
27

28
        // 禁用颜色和深度写入，只测试遮挡
29
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
30
        glDepthMask(GL_FALSE);
31
    }
32

33
    void end_occlusion_test(uint32_t object_id) {
34
        glEndQuery(GL_SAMPLES_PASSED);
35

36
        // 恢复渲染状态
37
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
38
        glDepthMask(GL_TRUE);
39

40
        auto& query = queries[object_id];
41
        query->result_available = false;
42
    }
43

44
    bool is_object_visible(uint32_t object_id, float visibility_threshold = 0.0f) {
45
        auto it = queries.find(object_id);
46
        if (it == queries.end()) {
47
            return true;  // 默认可见
48
        }
49

50
        auto& query = it->second;
51

52
        if (!query->result_available) {
53
            GLint available;
54
            glGetQueryObjectiv(query->query_id, GL_QUERY_RESULT_AVAILABLE, &available);
55

56
            if (available) {
57
                glGetQueryObjectuiv(query->query_id, GL_QUERY_RESULT, &query->sample_count);
58
                query->result_available = true;
59
            } else {
60
                return true;  // 结果未准备好，假设可见
61
            }
62
        }
63

64
        return query->sample_count > visibility_threshold;
65
    }
66

67
private:
68
    std::unique_ptr<OcclusionQuery>& get_or_create_query(uint32_t object_id) {
69
        auto it = queries.find(object_id);
70
        if (it == queries.end()) {
71
            queries[object_id] = std::make_unique<OcclusionQuery>();
72
        }
73
        return queries[object_id];
74
    }
75
};

25.3 GPU性能优化#

25.3.1 批处理优化#

1
class BatchRenderer {
2
private:
3
    struct BatchData {
4
        std::vector<Matrix4f> model_matrices;
5
        std::vector<Vector4f> colors;
6
        std::vector<Vector2f> texture_coords;
7
        GLuint vao, vbo, instance_vbo;
8
        int instance_count;
9

10
        BatchData() : instance_count(0) {
11
            glGenVertexArrays(1, &vao);
12
            glGenBuffers(1, &vbo);
13
            glGenBuffers(1, &instance_vbo);
14
        }
15

16
        ~BatchData() {
17
            glDeleteVertexArrays(1, &vao);
18
            glDeleteBuffers(1, &vbo);
19
            glDeleteBuffers(1, &instance_vbo);
20
        }
21
    };
22

23
    std::unordered_map<uint32_t, std::unique_ptr<BatchData>> batches;
24

25
public:
26
    void add_instance(uint32_t batch_id, const Matrix4f& model_matrix,
27
                     const Vector4f& color, const Vector2f& tex_coord) {
28
        auto& batch = get_or_create_batch(batch_id);
29

30
        batch->model_matrices.push_back(model_matrix);
31
        batch->colors.push_back(color);
32
        batch->texture_coords.push_back(tex_coord);
33
        batch->instance_count++;
34
    }
35

36
    void render_batch(uint32_t batch_id, const Mesh& mesh, const Shader& shader) {
37
        auto it = batches.find(batch_id);
38
        if (it == batches.end() || it->second->instance_count == 0) {
39
            return;
40
        }
41

42
        auto& batch = it->second;
43

44
        // 更新实例数据
45
        update_instance_buffer(*batch);
46

47
        // 绑定VAO和设置顶点属性
48
        glBindVertexArray(batch->vao);
49
        setup_vertex_attributes(mesh, *batch);
50

51
        // 使用着色器
52
        shader.use();
53

54
        // 实例化渲染
55
        glDrawElementsInstanced(GL_TRIANGLES, mesh.index_count(),
56
                               GL_UNSIGNED_INT, 0, batch->instance_count);
57

58
        // 清空批次数据
59
        clear_batch(*batch);
60
    }
61

62
private:
63
    std::unique_ptr<BatchData>& get_or_create_batch(uint32_t batch_id) {
64
        auto it = batches.find(batch_id);
65
        if (it == batches.end()) {
66
            batches[batch_id] = std::make_unique<BatchData>();
67
        }
68
        return batches[batch_id];
69
    }
70

71
    void update_instance_buffer(BatchData& batch) {
72
        glBindBuffer(GL_ARRAY_BUFFER, batch.instance_vbo);
73

74
        // 计算总数据大小
75
        size_t matrix_size = batch.model_matrices.size() * sizeof(Matrix4f);
76
        size_t color_size = batch.colors.size() * sizeof(Vector4f);
77
        size_t texcoord_size = batch.texture_coords.size() * sizeof(Vector2f);
78
        size_t total_size = matrix_size + color_size + texcoord_size;
79

80
        // 分配缓冲区
81
        glBufferData(GL_ARRAY_BUFFER, total_size, nullptr, GL_DYNAMIC_DRAW);
82

83
        // 上传数据
84
        glBufferSubData(GL_ARRAY_BUFFER, 0, matrix_size, batch.model_matrices.data());
85
        glBufferSubData(GL_ARRAY_BUFFER, matrix_size, color_size, batch.colors.data());
86
        glBufferSubData(GL_ARRAY_BUFFER, matrix_size + color_size, texcoord_size,
87
                       batch.texture_coords.data());
88
    }
89

90
    void setup_vertex_attributes(const Mesh& mesh, const BatchData& batch) {
91
        // 设置网格顶点属性
92
        mesh.bind_vertex_attributes();
93

94
        // 设置实例属性
95
        size_t matrix_size = batch.model_matrices.size() * sizeof(Matrix4f);
96
        size_t color_size = batch.colors.size() * sizeof(Vector4f);
97

98
        glBindBuffer(GL_ARRAY_BUFFER, batch.instance_vbo);
99

100
        // 模型矩阵（4个vec4）
101
        for (int i = 0; i < 4; ++i) {
102
            glEnableVertexAttribArray(3 + i);
103
            glVertexAttribPointer(3 + i, 4, GL_FLOAT, GL_FALSE, sizeof(Matrix4f),
104
                                 (void*)(i * sizeof(Vector4f)));
105
            glVertexAttribDivisor(3 + i, 1);
106
        }
107

108
        // 颜色
109
        glEnableVertexAttribArray(7);
110
        glVertexAttribPointer(7, 4, GL_FLOAT, GL_FALSE, sizeof(Vector4f),
111
                             (void*)matrix_size);
112
        glVertexAttribDivisor(7, 1);
113

114
        // 纹理坐标
115
        glEnableVertexAttribArray(8);
116
        glVertexAttribPointer(8, 2, GL_FLOAT, GL_FALSE, sizeof(Vector2f),
117
                             (void*)(matrix_size + color_size));
118
        glVertexAttribDivisor(8, 1);
119
    }
120

121
    void clear_batch(BatchData& batch) {
122
        batch.model_matrices.clear();
123
        batch.colors.clear();
124
        batch.texture_coords.clear();
125
        batch.instance_count = 0;
126
    }
127
};

基于物理的渲染(PBR)#

26.1 PBR理论基础#

26.1.1 渲染方程#

完整渲染方程： $L_o(p, \omega_o) = L_e(p, \omega_o) + \int_{\Omega} f_r(p, \omega_i, \omega_o) L_i(p, \omega_i) (\omega_i \cdot n) d\omega_i$

其中：

$L_o(p, \omega_o)$ 是从点p向方向 $\omega_o$ 的出射辐射度
$L_e(p, \omega_o)$ 是自发光
$f_r(p, \omega_i, \omega_o)$ 是双向反射分布函数(BRDF)
$L_i(p, \omega_i)$ 是入射辐射度
$(\omega_i \cdot n)$ 是Lambert余弦定律

26.1.2 BRDF模型#

Cook-Torrance BRDF： $f_r = k_d f_{lambert} + k_s f_{cook-torrance}$

其中： $f_{lambert} = \frac{c}{\pi}$ $f_{cook-torrance} = \frac{DFG}{4(\omega_o \cdot n)(\omega_i \cdot n)}$

法线分布函数(D)： $D_{GGX}(n, h, \alpha) = \frac{\alpha^2}{\pi((n \cdot h)^2(\alpha^2 - 1) + 1)^2}$

几何函数(G)： $G(n, v, l, k) = G_1(n, v, k) G_1(n, l, k)$ $G_1(n, v, k) = \frac{n \cdot v}{(n \cdot v)(1 - k) + k}$

菲涅尔项(F)： $F_{Schlick}(h, v, F_0) = F_0 + (1 - F_0)(1 - (h \cdot v))^5$

1
class PBRMaterial {
2
private:
3
    Vector3f albedo;
4
    float metallic;
5
    float roughness;
6
    float ao;  // 环境遮挡
7
    Vector3f F0;  // 基础反射率
8

9
public:
10
    PBRMaterial(const Vector3f& albedo, float metallic, float roughness, float ao = 1.0f)
11
        : albedo(albedo), metallic(metallic), roughness(roughness), ao(ao) {
12
        // 计算基础反射率
13
        F0 = Vector3f(0.04f, 0.04f, 0.04f);  // 非金属默认值
14
        F0 = F0 * (1.0f - metallic) + albedo * metallic;
15
    }
16

17
    Vector3f evaluate_brdf(const Vector3f& light_dir, const Vector3f& view_dir,
18
                          const Vector3f& normal) const {
19
        Vector3f h = (light_dir + view_dir).normalized();
20

21
        float NdotV = std::max(normal.dot(view_dir), 0.0f);
22
        float NdotL = std::max(normal.dot(light_dir), 0.0f);
23
        float HdotV = std::max(h.dot(view_dir), 0.0f);
24
        float NdotH = std::max(normal.dot(h), 0.0f);
25

26
        // 法线分布函数 (GGX/Trowbridge-Reitz)
27
        float D = distribution_ggx(NdotH, roughness);
28

29
        // 几何函数
30
        float G = geometry_smith(normal, view_dir, light_dir, roughness);
31

32
        // 菲涅尔项
33
        Vector3f F = fresnel_schlick(HdotV, F0);
34

35
        // Cook-Torrance BRDF
36
        Vector3f numerator = D * G * F;
37
        float denominator = 4.0f * NdotV * NdotL + 0.0001f;  // 防止除零
38
        Vector3f specular = numerator / denominator;
39

40
        // 漫反射部分
41
        Vector3f kS = F;
42
        Vector3f kD = Vector3f(1.0f, 1.0f, 1.0f) - kS;
43
        kD *= 1.0f - metallic;  // 金属没有漫反射
44

45
        Vector3f diffuse = kD * albedo / M_PI;
46

47
        return (diffuse + specular) * NdotL;
48
    }
49

50
private:
51
    float distribution_ggx(float NdotH, float roughness) const {
52
        float a = roughness * roughness;
53
        float a2 = a * a;
54
        float NdotH2 = NdotH * NdotH;
55

56
        float num = a2;
57
        float denom = (NdotH2 * (a2 - 1.0f) + 1.0f);
58
        denom = M_PI * denom * denom;
59

60
        return num / denom;
61
    }
62

63
    float geometry_schlick_ggx(float NdotV, float roughness) const {
64
        float r = (roughness + 1.0f);
65
        float k = (r * r) / 8.0f;
66

67
        float num = NdotV;
68
        float denom = NdotV * (1.0f - k) + k;
69

70
        return num / denom;
71
    }
72

73
    float geometry_smith(const Vector3f& N, const Vector3f& V,
74
                        const Vector3f& L, float roughness) const {
75
        float NdotV = std::max(N.dot(V), 0.0f);
76
        float NdotL = std::max(N.dot(L), 0.0f);
77
        float ggx2 = geometry_schlick_ggx(NdotV, roughness);
78
        float ggx1 = geometry_schlick_ggx(NdotL, roughness);
79

80
        return ggx1 * ggx2;
81
    }
82

83
    Vector3f fresnel_schlick(float cosTheta, const Vector3f& F0) const {
84
        return F0 + (Vector3f(1.0f, 1.0f, 1.0f) - F0) *
85
               std::pow(std::clamp(1.0f - cosTheta, 0.0f, 1.0f), 5.0f);
86
    }
87
};

26.2 基于图像的光照(IBL)#

26.2.1 环境贴图#

1
class IBLRenderer {
2
private:
3
    GLuint environment_map;
4
    GLuint irradiance_map;
5
    GLuint prefilter_map;
6
    GLuint brdf_lut;
7

8
public:
9
    void setup_ibl(const std::string& hdr_path) {
10
        // 加载HDR环境贴图
11
        load_hdr_environment(hdr_path);
12

13
        // 生成辐照度贴图
14
        generate_irradiance_map();
15

16
        // 生成预过滤环境贴图
17
        generate_prefilter_map();
18

19
        // 生成BRDF查找表
20
        generate_brdf_lut();
21
    }
22

23
    Vector3f sample_environment_lighting(const Vector3f& normal, const Vector3f& view_dir,
24
                                        const PBRMaterial& material) const {
25
        Vector3f reflection = reflect(-view_dir, normal);
26

27
        // 漫反射部分：从辐照度贴图采样
28
        Vector3f irradiance = sample_irradiance_map(normal);
29
        Vector3f diffuse = irradiance * material.get_albedo();
30

31
        // 镜面反射部分：从预过滤贴图采样
32
        float roughness = material.get_roughness();
33
        Vector3f prefiltered_color = sample_prefilter_map(reflection, roughness);
34

35
        // BRDF积分
36
        float NdotV = std::max(normal.dot(view_dir), 0.0f);
37
        Vector2f brdf_sample = sample_brdf_lut(NdotV, roughness);
38
        Vector3f F0 = material.get_F0();
39
        Vector3f specular = prefiltered_color * (F0 * brdf_sample.x() + brdf_sample.y());
40

41
        // 组合结果
42
        Vector3f kS = fresnel_schlick_roughness(NdotV, F0, roughness);
43
        Vector3f kD = Vector3f(1.0f, 1.0f, 1.0f) - kS;
44
        kD *= 1.0f - material.get_metallic();
45

46
        return kD * diffuse + specular;
47
    }
48

49
private:
50
    void load_hdr_environment(const std::string& path) {
51
        // 加载HDR图像
52
        int width, height, channels;
53
        float* data = stbi_loadf(path.c_str(), &width, &height, &channels, 0);
54

55
        if (data) {
56
            glGenTextures(1, &environment_map);
57
            glBindTexture(GL_TEXTURE_2D, environment_map);
58
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, width, height, 0, GL_RGB, GL_FLOAT, data);
59

60
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
61
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
62
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
63
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
64

65
            stbi_image_free(data);
66
        }
67
    }
68

69
    void generate_irradiance_map() {
70
        // 创建立方体贴图
71
        glGenTextures(1, &irradiance_map);
72
        glBindTexture(GL_TEXTURE_CUBE_MAP, irradiance_map);
73

74
        for (unsigned int i = 0; i < 6; ++i) {
75
            glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F,
76
                        32, 32, 0, GL_RGB, GL_FLOAT, nullptr);
77
        }
78

79
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
80
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
81
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
82
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
83
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
84

85
        // 使用计算着色器或渲染到立方体贴图的方式生成辐照度贴图
86
        render_irradiance_convolution();
87
    }
88

89
    void generate_prefilter_map() {
90
        glGenTextures(1, &prefilter_map);
91
        glBindTexture(GL_TEXTURE_CUBE_MAP, prefilter_map);
92

93
        for (unsigned int i = 0; i < 6; ++i) {
94
            glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F,
95
                        128, 128, 0, GL_RGB, GL_FLOAT, nullptr);
96
        }
97

98
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
99
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
100
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
101
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
102
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
103

104
        glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
105

106
        // 为每个mip级别渲染不同粗糙度的预过滤贴图
107
        render_prefilter_convolution();
108
    }
109

110
    void generate_brdf_lut() {
111
        glGenTextures(1, &brdf_lut);
112
        glBindTexture(GL_TEXTURE_2D, brdf_lut);
113
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, 512, 512, 0, GL_RG, GL_FLOAT, 0);
114

115
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
116
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
117
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
118
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
119

120
        // 渲染BRDF积分查找表
121
        render_brdf_integration();
122
    }
123

124
    Vector3f fresnel_schlick_roughness(float cosTheta, const Vector3f& F0, float roughness) const {
125
        return F0 + (std::max(Vector3f(1.0f - roughness, 1.0f - roughness, 1.0f - roughness), F0) - F0) *
126
               std::pow(std::clamp(1.0f - cosTheta, 0.0f, 1.0f), 5.0f);
127
    }
128
};

体积渲染与参与介质#

27.1 体积渲染理论#

27.1.1 体积渲染方程#

体积渲染积分方程： $L(x, \omega) = \int_0^d T(x, x + t\omega) \sigma_s(x + t\omega) \int_{4\pi} p(x + t\omega, \omega', \omega) L(x + t\omega, \omega') d\omega' dt + T(x, x + d\omega) L(x + d\omega, \omega)$

其中：

$T(x, y)$ 是透射率函数
$\sigma_s$ 是散射系数
$p(\omega', \omega)$ 是相位函数
$d$ 是光线传播距离

透射率函数： $T(x, y) = \exp\left(-\int_0^{||y-x||} \sigma_t(x + s \cdot \frac{y-x}{||y-x||}) ds\right)$

相位函数(Henyey-Greenstein)： $p(\cos\theta) = \frac{1 - g^2}{4\pi(1 + g^2 - 2g\cos\theta)^{3/2}}$

其中 $g \in [-1, 1]$ 是各向异性参数。

1
class VolumeRenderer {
2
private:
3
    struct VolumeProperties {
4
        float density;           // 密度
5
        float absorption;        // 吸收系数
6
        float scattering;        // 散射系数
7
        float anisotropy;        // 各向异性参数g
8
        Vector3f albedo;         // 散射反照率
9

10
        float extinction() const { return absorption + scattering; }
11
    };
12

13
    struct VolumeData {
14
        std::vector<float> density_grid;
15
        int width, height, depth;
16
        Vector3f bounds_min, bounds_max;
17

18
        float sample_density(const Vector3f& pos) const {
19
            // 三线性插值采样密度
20
            Vector3f normalized_pos = (pos - bounds_min).cwiseQuotient(bounds_max - bounds_min);
21

22
            if (normalized_pos.x() < 0 || normalized_pos.x() > 1 ||
23
                normalized_pos.y() < 0 || normalized_pos.y() > 1 ||
24
                normalized_pos.z() < 0 || normalized_pos.z() > 1) {
25
                return 0.0f;
26
            }
27

28
            return trilinear_interpolate(normalized_pos);
29
        }
30

31
    private:
32
        float trilinear_interpolate(const Vector3f& pos) const {
33
            float x = pos.x() * (width - 1);
34
            float y = pos.y() * (height - 1);
35
            float z = pos.z() * (depth - 1);
36

37
            int x0 = static_cast<int>(x), x1 = std::min(x0 + 1, width - 1);
38
            int y0 = static_cast<int>(y), y1 = std::min(y0 + 1, height - 1);
39
            int z0 = static_cast<int>(z), z1 = std::min(z0 + 1, depth - 1);
40

41
            float fx = x - x0, fy = y - y0, fz = z - z0;
42

43
            auto get_density = [this](int x, int y, int z) {
44
                return density_grid[z * width * height + y * width + x];
45
            };
46

47
            // 三线性插值
48
            float c000 = get_density(x0, y0, z0);
49
            float c001 = get_density(x0, y0, z1);
50
            float c010 = get_density(x0, y1, z0);
51
            float c011 = get_density(x0, y1, z1);
52
            float c100 = get_density(x1, y0, z0);
53
            float c101 = get_density(x1, y0, z1);
54
            float c110 = get_density(x1, y1, z0);
55
            float c111 = get_density(x1, y1, z1);
56

57
            float c00 = c000 * (1 - fx) + c100 * fx;
58
            float c01 = c001 * (1 - fx) + c101 * fx;
59
            float c10 = c010 * (1 - fx) + c110 * fx;
60
            float c11 = c011 * (1 - fx) + c111 * fx;
61

62
            float c0 = c00 * (1 - fy) + c10 * fy;
63
            float c1 = c01 * (1 - fy) + c11 * fy;
64

65
            return c0 * (1 - fz) + c1 * fz;
66
        }
67
    };
68

69
    VolumeData volume_data;
70
    VolumeProperties volume_props;
71

72
public:
73
    Vector3f render_volume_ray(const Ray& ray, float t_min, float t_max,
74
                              const std::vector<Light>& lights) const {
75
        Vector3f color(0, 0, 0);
76
        float transmittance = 1.0f;
77

78
        // 光线步进参数
79
        float step_size = 0.1f;
80
        int num_steps = static_cast<int>((t_max - t_min) / step_size);
81

82
        for (int i = 0; i < num_steps; ++i) {
83
            float t = t_min + i * step_size;
84
            Vector3f pos = ray.origin + t * ray.direction;
85

86
            // 采样体积密度
87
            float density = volume_data.sample_density(pos);
88
            if (density <= 0.0f) continue;
89

90
            // 计算体积属性
91
            float extinction = volume_props.extinction() * density;
92
            float scattering = volume_props.scattering * density;
93

94
            // 计算透射率衰减
95
            float step_transmittance = std::exp(-extinction * step_size);
96

97
            // 计算散射光照
98
            Vector3f scattered_light = calculate_in_scattering(pos, -ray.direction, lights, density);
99

100
            // 累积颜色
101
            color += transmittance * (1.0f - step_transmittance) * scattered_light;
102

103
            // 更新透射率
104
            transmittance *= step_transmittance;
105

106
            // 早期终止优化
107
            if (transmittance < 0.01f) break;
108
        }
109

110
        return color;
111
    }
112

113
private:
114
    Vector3f calculate_in_scattering(const Vector3f& pos, const Vector3f& view_dir,
115
                                   const std::vector<Light>& lights, float density) const {
116
        Vector3f scattered_light(0, 0, 0);
117

118
        for (const auto& light : lights) {
119
            Vector3f light_dir = (light.position - pos).normalized();
120
            float light_distance = (light.position - pos).norm();
121

122
            // 计算到光源的透射率
123
            float light_transmittance = calculate_transmittance(pos, light.position);
124

125
            // 相位函数
126
            float cos_theta = view_dir.dot(light_dir);
127
            float phase = henyey_greenberg_phase(cos_theta, volume_props.anisotropy);
128

129
            // 光照衰减
130
            float attenuation = 1.0f / (light_distance * light_distance);
131

132
            // 散射贡献
133
            Vector3f light_contribution = light.color * light.intensity * attenuation *
134
                                        light_transmittance * phase * volume_props.scattering * density;
135

136
            scattered_light += light_contribution * volume_props.albedo;
137
        }
138

139
        return scattered_light;
140
    }
141

142
    float calculate_transmittance(const Vector3f& start, const Vector3f& end) const {
143
        Vector3f direction = (end - start).normalized();
144
        float distance = (end - start).norm();
145

146
        float transmittance = 1.0f;
147
        float step_size = 0.1f;
148
        int num_steps = static_cast<int>(distance / step_size);
149

150
        for (int i = 0; i < num_steps; ++i) {
151
            float t = i * step_size;
152
            Vector3f pos = start + t * direction;
153

154
            float density = volume_data.sample_density(pos);
155
            float extinction = volume_props.extinction() * density;
156

157
            transmittance *= std::exp(-extinction * step_size);
158

159
            if (transmittance < 0.01f) break;
160
        }
161

162
        return transmittance;
163
    }
164

165
    float henyey_greenberg_phase(float cos_theta, float g) const {
166
        float g2 = g * g;
167
        float denom = 1.0f + g2 - 2.0f * g * cos_theta;
168
        return (1.0f - g2) / (4.0f * M_PI * std::pow(denom, 1.5f));
169
    }
170
};

27.2 云渲染#

1
class CloudRenderer {
2
private:
3
    struct CloudLayer {
4
        float altitude_min, altitude_max;
5
        float density_multiplier;
6
        float coverage;
7
        Vector2f wind_direction;
8
        float wind_speed;
9

10
        // 噪声参数
11
        float noise_scale;
12
        float detail_scale;
13
        int octaves;
14
    };
15

16
    std::vector<CloudLayer> cloud_layers;
17
    GLuint noise_texture_3d;
18
    GLuint weather_texture;
19

20
public:
21
    void setup_cloud_system() {
22
        // 生成3D噪声纹理
23
        generate_3d_noise_texture();
24

25
        // 生成天气贴图
26
        generate_weather_texture();
27

28
        // 设置云层
29
        setup_cloud_layers();
30
    }
31

32
    Vector4f render_clouds(const Ray& ray, float t_min, float t_max,
33
                          const Vector3f& sun_direction) const {
34
        Vector3f color(0, 0, 0);
35
        float alpha = 0.0f;
36

37
        // 光线步进
38
        float step_size = 100.0f;  // 云渲染使用较大步长
39
        int num_steps = static_cast<int>((t_max - t_min) / step_size);
40

41
        for (int i = 0; i < num_steps; ++i) {
42
            float t = t_min + i * step_size;
43
            Vector3f pos = ray.origin + t * ray.direction;
44

45
            // 采样云密度
46
            float cloud_density = sample_cloud_density(pos);
47
            if (cloud_density <= 0.0f) continue;
48

49
            // 计算光照
50
            Vector3f light_color = calculate_cloud_lighting(pos, sun_direction, cloud_density);
51

52
            // 透明度混合
53
            float step_alpha = 1.0f - std::exp(-cloud_density * step_size * 0.01f);
54
            color += (1.0f - alpha) * step_alpha * light_color;
55
            alpha += (1.0f - alpha) * step_alpha;
56

57
            // 早期终止
58
            if (alpha > 0.99f) break;
59
        }
60

61
        return Vector4f(color.x(), color.y(), color.z(), alpha);
62
    }
63

64
private:
65
    float sample_cloud_density(const Vector3f& pos) const {
66
        float total_density = 0.0f;
67

68
        for (const auto& layer : cloud_layers) {
69
            if (pos.y() < layer.altitude_min || pos.y() > layer.altitude_max) {
70
                continue;
71
            }
72

73
            // 高度衰减
74
            float height_fraction = (pos.y() - layer.altitude_min) /
75
                                  (layer.altitude_max - layer.altitude_min);
76
            float height_gradient = 4.0f * height_fraction * (1.0f - height_fraction);
77

78
            // 基础噪声
79
            Vector3f noise_coord = pos * layer.noise_scale;
80
            float base_noise = sample_3d_noise(noise_coord);
81

82
            // 细节噪声
83
            Vector3f detail_coord = pos * layer.detail_scale;
84
            float detail_noise = sample_3d_noise(detail_coord);
85

86
            // 组合噪声
87
            float combined_noise = base_noise * 0.7f + detail_noise * 0.3f;
88

89
            // 应用覆盖率和高度梯度
90
            float density = std::max(0.0f, combined_noise - (1.0f - layer.coverage));
91
            density *= height_gradient * layer.density_multiplier;
92

93
            total_density += density;
94
        }
95

96
        return std::min(total_density, 1.0f);
97
    }
98

99
    Vector3f calculate_cloud_lighting(const Vector3f& pos, const Vector3f& sun_dir,
100
                                    float density) const {
101
        // 基础环境光
102
        Vector3f ambient = Vector3f(0.6f, 0.7f, 0.8f) * 0.3f;
103

104
        // 太阳光散射
105
        float sun_transmittance = calculate_sun_transmittance(pos, sun_dir);
106
        Vector3f sun_color = Vector3f(1.0f, 0.9f, 0.7f) * sun_transmittance;
107

108
        // Henyey-Greenberg相位函数（云的前向散射）
109
        float cos_theta = -sun_dir.dot(Vector3f(0, -1, 0));  // 假设视线向下
110
        float phase = henyey_greenberg_phase(cos_theta, 0.3f);  // 轻微前向散射
111

112
        // 组合光照
113
        Vector3f total_light = ambient + sun_color * phase;
114

115
        // 应用密度
116
        return total_light * density;
117
    }
118

119
    float calculate_sun_transmittance(const Vector3f& pos, const Vector3f& sun_dir) const {
120
        // 简化的太阳光透射率计算
121
        float transmittance = 1.0f;
122
        float step_size = 50.0f;
123

124
        for (int i = 0; i < 10; ++i) {  // 有限步数的光线行进
125
            Vector3f sample_pos = pos + i * step_size * sun_dir;
126
            float density = sample_cloud_density(sample_pos);
127
            transmittance *= std::exp(-density * step_size * 0.005f);
128

129
            if (transmittance < 0.1f) break;
130
        }
131

132
        return transmittance;
133
    }
134

135
    float sample_3d_noise(const Vector3f& coord) const {
136
        // 这里应该从3D噪声纹理采样
137
        // 简化实现：使用程序化噪声
138
        return (std::sin(coord.x()) * std::cos(coord.y()) * std::sin(coord.z()) + 1.0f) * 0.5f;
139
    }
140

141
    void generate_3d_noise_texture() {
142
        // 生成3D Perlin噪声纹理
143
        const int size = 128;
144
        std::vector<float> noise_data(size * size * size);
145

146
        for (int z = 0; z < size; ++z) {
147
            for (int y = 0; y < size; ++y) {
148
                for (int x = 0; x < size; ++x) {
149
                    Vector3f coord(x / float(size), y / float(size), z / float(size));
150
                    int index = z * size * size + y * size + x;
151
                    noise_data[index] = generate_perlin_noise(coord * 8.0f);
152
                }
153
            }
154
        }
155

156
        glGenTextures(1, &noise_texture_3d);
157
        glBindTexture(GL_TEXTURE_3D, noise_texture_3d);
158
        glTexImage3D(GL_TEXTURE_3D, 0, GL_R16F, size, size, size, 0, GL_RED, GL_FLOAT, noise_data.data());
159

160
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
161
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
162
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
163
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
164
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
165
    }
166

167
    float generate_perlin_noise(const Vector3f& coord) const {
168
        // 简化的Perlin噪声实现
169
        return (std::sin(coord.x()) * std::cos(coord.y()) * std::sin(coord.z()) + 1.0f) * 0.5f;
170
    }
171

172
    float henyey_greenberg_phase(float cos_theta, float g) const {
173
        float g2 = g * g;
174
        float denom = 1.0f + g2 - 2.0f * g * cos_theta;
175
        return (1.0f - g2) / (4.0f * M_PI * std::pow(denom, 1.5f));
176
    }
177
};

计算着色器与GPGPU#

28.1 计算着色器基础#

28.1.1 工作组和线程模型#

工作组大小：

本地工作组大小： $(local\_size\_x, local\_size\_y, local\_size\_z)$
全局工作组数量： $(num\_groups\_x, num\_groups\_y, num\_groups\_z)$
总线程数： $total\_threads = local\_size \times num\_groups$

线程索引计算： $global\_id = local\_id + group\_id \times local\_size$

1
class ComputeShaderManager {
2
private:
3
    struct ComputeProgram {
4
        GLuint program_id;
5
        GLuint shader_id;
6
        std::unordered_map<std::string, GLint> uniform_locations;
7

8
        ComputeProgram() : program_id(0), shader_id(0) {}
9

10
        ~ComputeProgram() {
11
            if (shader_id) glDeleteShader(shader_id);
12
            if (program_id) glDeleteProgram(program_id);
13
        }
14
    };
15

16
    std::unordered_map<std::string, std::unique_ptr<ComputeProgram>> programs;
17

18
public:
19
    bool create_compute_program(const std::string& name, const std::string& source) {
20
        auto program = std::make_unique<ComputeProgram>();
21

22
        // 创建计算着色器
23
        program->shader_id = glCreateShader(GL_COMPUTE_SHADER);
24
        const char* source_ptr = source.c_str();
25
        glShaderSource(program->shader_id, 1, &source_ptr, nullptr);
26
        glCompileShader(program->shader_id);
27

28
        // 检查编译错误
29
        GLint success;
30
        glGetShaderiv(program->shader_id, GL_COMPILE_STATUS, &success);
31
        if (!success) {
32
            char info_log[512];
33
            glGetShaderInfoLog(program->shader_id, 512, nullptr, info_log);
34
            std::cerr << "计算着色器编译失败: " << info_log << std::endl;
35
            return false;
36
        }
37

38
        // 创建程序
39
        program->program_id = glCreateProgram();
40
        glAttachShader(program->program_id, program->shader_id);
41
        glLinkProgram(program->program_id);
42

43
        // 检查链接错误
44
        glGetProgramiv(program->program_id, GL_LINK_STATUS, &success);
45
        if (!success) {
46
            char info_log[512];
47
            glGetProgramInfoLog(program->program_id, 512, nullptr, info_log);
48
            std::cerr << "计算着色器程序链接失败: " << info_log << std::endl;
49
            return false;
50
        }
51

52
        programs[name] = std::move(program);
53
        return true;
54
    }
55

56
    void dispatch_compute(const std::string& program_name,
57
                         GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
58
        auto it = programs.find(program_name);
59
        if (it == programs.end()) {
60
            std::cerr << "计算着色器程序未找到: " << program_name << std::endl;
61
            return;
62
        }
63

64
        glUseProgram(it->second->program_id);
65
        glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
66
        glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
67
    }
68

69
    void set_uniform(const std::string& program_name, const std::string& uniform_name,
70
                    float value) {
71
        auto it = programs.find(program_name);
72
        if (it == programs.end()) return;
73

74
        auto& program = it->second;
75
        auto uniform_it = program->uniform_locations.find(uniform_name);
76

77
        GLint location;
78
        if (uniform_it == program->uniform_locations.end()) {
79
            location = glGetUniformLocation(program->program_id, uniform_name.c_str());
80
            program->uniform_locations[uniform_name] = location;
81
        } else {
82
            location = uniform_it->second;
83
        }
84

85
        if (location != -1) {
86
            glUseProgram(program->program_id);
87
            glUniform1f(location, value);
88
        }
89
    }
90
};

28.2 并行算法实现#

28.2.1 并行前缀和(Prefix Sum)#

1
class ParallelPrefixSum {
2
private:
3
    ComputeShaderManager compute_manager;
4
    GLuint input_buffer, output_buffer, temp_buffer;
5

6
    const std::string upsweep_shader = R"(
7
        #version 430
8
        layout(local_size_x = 256) in;
9

10
        layout(std430, binding = 0) restrict buffer InputBuffer {
11
            float input_data[];
12
        };
13

14
        layout(std430, binding = 1) restrict buffer TempBuffer {
15
            float temp_data[];
16
        };
17

18
        uniform int step;
19
        uniform int n;
20

21
        void main() {
22
            uint index = gl_GlobalInvocationID.x;
23
            uint stride = 1u << step;
24
            uint read_index = (index + 1u) * stride * 2u - 1u;
25

26
            if (read_index < n) {
27
                uint write_index = read_index + stride;
28
                if (write_index < n) {
29
                    temp_data[write_index] += temp_data[read_index];
30
                }
31
            }
32
        }
33
    )";
34

35
    const std::string downsweep_shader = R"(
36
        #version 430
37
        layout(local_size_x = 256) in;
38

39
        layout(std430, binding = 1) restrict buffer TempBuffer {
40
            float temp_data[];
41
        };
42

43
        layout(std430, binding = 2) restrict buffer OutputBuffer {
44
            float output_data[];
45
        };
46

47
        uniform int step;
48
        uniform int n;
49

50
        void main() {
51
            uint index = gl_GlobalInvocationID.x;
52
            uint stride = 1u << (step + 1);
53
            uint read_index = (index + 1u) * stride - 1u;
54

55
            if (read_index < n) {
56
                uint write_index = read_index + (stride >> 1);
57
                if (write_index < n) {
58
                    float temp = temp_data[read_index];
59
                    temp_data[read_index] = temp_data[write_index];
60
                    temp_data[write_index] += temp;
61
                }
62
            }
63
        }
64
    )";
65

66
public:
67
    void setup(int max_size) {
68
        // 创建缓冲区
69
        glGenBuffers(1, &input_buffer);
70
        glGenBuffers(1, &output_buffer);
71
        glGenBuffers(1, &temp_buffer);
72

73
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, input_buffer);
74
        glBufferData(GL_SHADER_STORAGE_BUFFER, max_size * sizeof(float), nullptr, GL_DYNAMIC_DRAW);
75

76
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, output_buffer);
77
        glBufferData(GL_SHADER_STORAGE_BUFFER, max_size * sizeof(float), nullptr, GL_DYNAMIC_DRAW);
78

79
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, temp_buffer);
80
        glBufferData(GL_SHADER_STORAGE_BUFFER, max_size * sizeof(float), nullptr, GL_DYNAMIC_DRAW);
81

82
        // 编译着色器
83
        compute_manager.create_compute_program("upsweep", upsweep_shader);
84
        compute_manager.create_compute_program("downsweep", downsweep_shader);
85
    }
86

87
    void compute_prefix_sum(const std::vector<float>& input, std::vector<float>& output) {
88
        int n = input.size();
89
        output.resize(n);
90

91
        // 上传输入数据
92
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, input_buffer);
93
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, n * sizeof(float), input.data());
94

95
        // 复制到临时缓冲区
96
        glBindBuffer(GL_COPY_READ_BUFFER, input_buffer);
97
        glBindBuffer(GL_COPY_WRITE_BUFFER, temp_buffer);
98
        glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, n * sizeof(float));
99

100
        // 绑定缓冲区
101
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, input_buffer);
102
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, temp_buffer);
103
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, output_buffer);
104

105
        // Up-sweep阶段
106
        int steps = static_cast<int>(std::ceil(std::log2(n)));
107
        for (int step = 0; step < steps; ++step) {
108
            compute_manager.set_uniform("upsweep", "step", static_cast<float>(step));
109
            compute_manager.set_uniform("upsweep", "n", static_cast<float>(n));
110

111
            int num_groups = (n + 255) / 256;
112
            compute_manager.dispatch_compute("upsweep", num_groups, 1, 1);
113
        }
114

115
        // 清零最后一个元素
116
        float zero = 0.0f;
117
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, temp_buffer);
118
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, (n - 1) * sizeof(float), sizeof(float), &zero);
119

120
        // Down-sweep阶段
121
        for (int step = steps - 1; step >= 0; --step) {
122
            compute_manager.set_uniform("downsweep", "step", static_cast<float>(step));
123
            compute_manager.set_uniform("downsweep", "n", static_cast<float>(n));
124

125
            int num_groups = (n + 255) / 256;
126
            compute_manager.dispatch_compute("downsweep", num_groups, 1, 1);
127
        }
128

129
        // 复制结果
130
        glBindBuffer(GL_COPY_READ_BUFFER, temp_buffer);
131
        glBindBuffer(GL_COPY_WRITE_BUFFER, output_buffer);
132
        glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, n * sizeof(float));
133

134
        // 下载结果
135
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, output_buffer);
136
        float* result = static_cast<float*>(glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY));
137
        std::copy(result, result + n, output.begin());
138
        glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
139
    }
140
};

28.2.2 GPU粒子系统#

1
class GPUParticleSystem {
2
private:
3
    struct Particle {
4
        Vector3f position;
5
        float life;
6
        Vector3f velocity;
7
        float size;
8
        Vector4f color;
9
        Vector3f acceleration;
10
        float padding;
11
    };
12

13
    GLuint particle_buffer;
14
    GLuint counter_buffer;
15
    GLuint indirect_buffer;
16
    ComputeShaderManager compute_manager;
17

18
    const std::string update_shader = R"(
19
        #version 430
20
        layout(local_size_x = 256) in;
21

22
        struct Particle {
23
            vec3 position;
24
            float life;
25
            vec3 velocity;
26
            float size;
27
            vec4 color;
28
            vec3 acceleration;
29
            float padding;
30
        };
31

32
        layout(std430, binding = 0) restrict buffer ParticleBuffer {
33
            Particle particles[];
34
        };
35

36
        layout(std430, binding = 1) restrict buffer CounterBuffer {
37
            uint alive_count;
38
            uint dead_count;
39
            uint alive_list[];
40
        };
41

42
        uniform float delta_time;
43
        uniform vec3 gravity;
44
        uniform float damping;
45

46
        void main() {
47
            uint index = gl_GlobalInvocationID.x;
48
            if (index >= particles.length()) return;
49

50
            Particle p = particles[index];
51

52
            // 更新生命周期
53
            p.life -= delta_time;
54

55
            if (p.life > 0.0) {
56
                // 更新物理
57
                p.acceleration += gravity;
58
                p.velocity += p.acceleration * delta_time;
59
                p.velocity *= damping;
60
                p.position += p.velocity * delta_time;
61

62
                // 更新颜色（基于生命周期）
63
                float life_ratio = p.life / 5.0; // 假设最大生命周期为5秒
64
                p.color.a = life_ratio;
65

66
                // 重置加速度
67
                p.acceleration = vec3(0.0);
68

69
                particles[index] = p;
70

71
                // 添加到活跃列表
72
                uint alive_index = atomicAdd(alive_count, 1);
73
                alive_list[alive_index] = index;
74
            } else {
75
                // 粒子死亡
76
                atomicAdd(dead_count, 1);
77
            }
78
        }
79
    )";
80

81
    const std::string emit_shader = R"(
82
        #version 430
83
        layout(local_size_x = 64) in;
84

85
        struct Particle {
86
            vec3 position;
87
            float life;
88
            vec3 velocity;
89
            float size;
90
            vec4 color;
91
            vec3 acceleration;
92
            float padding;
93
        };
94

95
        layout(std430, binding = 0) restrict buffer ParticleBuffer {
96
            Particle particles[];
97
        };
98

99
        layout(std430, binding = 1) restrict buffer CounterBuffer {
100
            uint alive_count;
101
            uint dead_count;
102
            uint alive_list[];
103
        };
104

105
        uniform vec3 emitter_position;
106
        uniform vec3 emitter_direction;
107
        uniform float emit_rate;
108
        uniform float delta_time;
109
        uniform uint random_seed;
110

111
        // 简单的随机数生成器
112
        uint hash(uint x) {
113
            x += (x << 10u);
114
            x ^= (x >> 6u);
115
            x += (x << 3u);
116
            x ^= (x >> 11u);
117
            x += (x << 15u);
118
            return x;
119
        }
120

121
        float random(uint seed) {
122
            return float(hash(seed)) / 4294967295.0;
123
        }
124

125
        void main() {
126
            uint index = gl_GlobalInvocationID.x;
127

128
            // 计算需要发射的粒子数量
129
            uint emit_count = uint(emit_rate * delta_time);
130
            if (index >= emit_count) return;
131

132
            // 查找死亡的粒子进行重用
133
            if (dead_count > 0) {
134
                uint dead_index = atomicAdd(dead_count, -1) - 1;
135
                if (dead_index < particles.length()) {
136
                    uint particle_index = dead_index; // 简化：直接使用索引
137

138
                    // 初始化新粒子
139
                    uint seed = random_seed + index * 1000u;
140

141
                    particles[particle_index].position = emitter_position +
142
                        vec3(random(seed) - 0.5, random(seed + 1u) - 0.5, random(seed + 2u) - 0.5) * 2.0;
143

144
                    particles[particle_index].life = 3.0 + random(seed + 3u) * 2.0; // 3-5秒生命周期
145

146
                    vec3 random_dir = normalize(vec3(
147
                        random(seed + 4u) - 0.5,
148
                        random(seed + 5u) - 0.5,
149
                        random(seed + 6u) - 0.5
150
                    ));
151
                    particles[particle_index].velocity = emitter_direction + random_dir * 0.5;
152

153
                    particles[particle_index].size = 0.1 + random(seed + 7u) * 0.1;
154
                    particles[particle_index].color = vec4(1.0, 0.8, 0.2, 1.0);
155
                    particles[particle_index].acceleration = vec3(0.0);
156
                }
157
            }
158
        }
159
    )";
160

161
public:
162
    void setup(int max_particles) {
163
        // 创建粒子缓冲区
164
        glGenBuffers(1, &particle_buffer);
165
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, particle_buffer);
166
        glBufferData(GL_SHADER_STORAGE_BUFFER, max_particles * sizeof(Particle), nullptr, GL_DYNAMIC_DRAW);
167

168
        // 创建计数器缓冲区
169
        glGenBuffers(1, &counter_buffer);
170
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, counter_buffer);
171
        glBufferData(GL_SHADER_STORAGE_BUFFER, (2 + max_particles) * sizeof(GLuint), nullptr, GL_DYNAMIC_DRAW);
172

173
        // 初始化计数器
174
        GLuint initial_counts[2] = {0, static_cast<GLuint>(max_particles)};
175
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 2 * sizeof(GLuint), initial_counts);
176

177
        // 编译着色器
178
        compute_manager.create_compute_program("update_particles", update_shader);
179
        compute_manager.create_compute_program("emit_particles", emit_shader);
180
    }
181

182
    void update(float delta_time, const Vector3f& emitter_pos, const Vector3f& emitter_dir,
183
               float emit_rate) {
184
        // 绑定缓冲区
185
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, particle_buffer);
186
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, counter_buffer);
187

188
        // 重置活跃计数
189
        GLuint zero = 0;
190
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, counter_buffer);
191
        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint), &zero);
192

193
        // 更新粒子
194
        compute_manager.set_uniform("update_particles", "delta_time", delta_time);
195
        compute_manager.set_uniform("update_particles", "damping", 0.98f);
196
        compute_manager.dispatch_compute("update_particles", (10000 + 255) / 256, 1, 1);
197

198
        // 发射新粒子
199
        compute_manager.set_uniform("emit_particles", "delta_time", delta_time);
200
        compute_manager.set_uniform("emit_particles", "emit_rate", emit_rate);
201
        compute_manager.set_uniform("emit_particles", "random_seed",
202
                                  static_cast<float>(std::rand()));
203
        compute_manager.dispatch_compute("emit_particles", (64 + 63) / 64, 1, 1);
204
    }
205

206
    GLuint get_particle_buffer() const { return particle_buffer; }
207
    GLuint get_counter_buffer() const { return counter_buffer; }
208
};