使用計算着色器（Compute Shader）模拟粒子效果【OpenGL】【GLSL】

個人感覺計算着色器很像 CUDA，都是利用顯示卡的強大計算能力來加速，隻不過 CUDA 僅适用于 N 卡，而計算着色器具有跨平台的能力(Shader Model 5.0以上才支援)

效果如圖：

使用計算着色器（Compute Shader）模拟粒子效果【OpenGL】【GLSL】

關鍵代碼及注釋如下：

C++ 代碼

void initialize()
{
    // 計算着色器
    GLuint compute_shader = buildShader(
        &compute_shader_source, 
        GL_COMPUTE_SHADER, 
        "Error in compiling the compute shader\n");
 
    compute_prog = buildComputeProg(compute_shader);
 
    setupData();
    // ---------------------------------------------
    // 渲染着色器
    GLuint vs = buildShader(
        &render_vs, 
        GL_VERTEX_SHADER, 
        "Error in compiling the vertex shader\n");
 
    GLuint fs = buildShader(
        &render_fs,
        GL_FRAGMENT_SHADER,
        "Error in compiling the fragment shader\n");
 
    render_prog = buildRenderProg(vs, fs);
 
    // ---------------------------------------------
}

C++代碼：

// 激活頂點/紋理屬性
void setupData()
{
    dt_location = glGetUniformLocation(compute_prog, "dt");
 
    // 建立 VAO
    glGenVertexArrays(1, &render_vao);
    glBindVertexArray(render_vao);
 
    // 建立 VBO
    glGenBuffers(2, buffers);
 
    //glEnableVertexAttribArray(1); // 啟用索引為 1 的頂點屬性——粒子位置
    //glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL); // 表明 buffer 内資料的格式
 
    glBindBuffer(GL_ARRAY_BUFFER, position_buffer);
    glBufferData(GL_ARRAY_BUFFER, PARTICLE_COUNT * sizeof(glm::vec4), NULL, GL_DYNAMIC_COPY);   // 由于資料是不斷變化的，是以需要動态拷貝
 
    glm::vec4 * positions = (glm::vec4 *)glMapBufferRange(GL_ARRAY_BUFFER,
        0,
        PARTICLE_COUNT * sizeof(glm::vec4),
        GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
 
    for (int i = 0; i < PARTICLE_COUNT; i++)
    {
        positions[i] = glm::vec4(randomVector(-10.0f, 10.0f), randomFloat());
    }
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
 
 
    glEnableVertexAttribArray(0);   // 啟用索引為 0 的頂點屬性——粒子速度
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);   // 表明 buffer 内資料的格式
 
    glBindBuffer(GL_ARRAY_BUFFER, velocity_buffer); // 表明使用的 buffer 資料來源
    glBufferData(GL_ARRAY_BUFFER, PARTICLE_COUNT * sizeof(glm::vec4), NULL, GL_DYNAMIC_COPY);   // 由于資料是不斷變化的，是以需要動态拷貝
 
    glm::vec4 * velocities = (glm::vec4 *)glMapBufferRange(GL_ARRAY_BUFFER,
        0,
        PARTICLE_COUNT * sizeof(glm::vec4),
        GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
 
    for (int i = 0; i < PARTICLE_COUNT; i++)
    {
        velocities[i] = glm::vec4(randomVector(-0.1f, 0.1f), 0.0f);
    }
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
 
    // ---------------------
    // 建立 TBO
    glGenTextures(2, tbos);
 
    for (int i = 0; i < 2; i++)
    {
        glBindTexture(GL_TEXTURE_BUFFER, tbos[i]);
        glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, buffers[i]); // ☆ VBO 将從 TBO 中擷取資料，注意：buffers 是 position_buffer/velocity_buffer 的别名
    }
 
    // ---------------------
    // 建立 UBO
    glGenBuffers(1, &attractor_buffer);
    glBindBuffer(GL_UNIFORM_BUFFER, attractor_buffer);
    glBufferData(GL_UNIFORM_BUFFER, 32 * sizeof(glm::vec4), NULL, GL_STATIC_DRAW);  // 僅初始化，靜态拷貝
 
    // attractor 的最後一位，表示粒子品質
    for (int i = 0; i < MAX_ATTRACTORS; i++)
    {
        attractor_masses[i] = 0.5f + randomFloat() * 0.5f;
    }
 
    glBindBufferBase(GL_UNIFORM_BUFFER, 0, attractor_buffer);
 
    // --------------------------------------
}

C++ 代碼：

void display()
{
    static const GLuint start_ticks = ::GetTickCount() - 100000;
    GLuint current_ticks = ::GetTickCount();
    static GLuint last_ticks = current_ticks;
    float time = ((start_ticks - current_ticks) & 0xFFFFF) / float(0xFFFFF);
    float delta_time = (float)(current_ticks - last_ticks) * 0.075f;
 
    // ----------------------------------------------------
    // 映射 UBO
    glm::vec4 * attractors = (glm::vec4 *)glMapBufferRange(GL_UNIFORM_BUFFER,
        0,
        32 * sizeof(glm::vec4),
        GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
 
    int i;
 
    for (i = 0; i < 32; i++)
    {
        attractors[i] = glm::vec4(
            sinf(time * (float)(i + 4) * 7.5f * 20.0f) * 50.0f,
            cosf(time * (float)(i + 7) * 3.9f * 20.0f) * 50.0f,
            sinf(time * (float)(i + 3) * 5.3f * 20.0f) * cosf(time * (float)(i + 5) * 9.1f) * 100.0f,
            attractor_masses[i]);
        //std::cout << "attractors = " << attractors[i][0] << std::endl;
    }
 
    glUnmapBuffer(GL_UNIFORM_BUFFER);
 
    // ----------------------------------------------------
    // 激活 計算着色器，并綁定到 TBO（存儲粒子的位置和速度）
    glUseProgram(compute_prog);
    glBindImageTexture(0, velocity_tbo, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);// 既可讀又可寫，注意可以省去 glActiveTexture 的調用
    glBindImageTexture(1, position_tbo, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
    // 為 計算着色器傳參——delta time
    // If dt is too large, the system could explode, so cap it to
    // some maximum allowed value
    if (delta_time >= 2.0f)
    {
        delta_time = 2.0f;
    }
    glUniform1f(dt_location, delta_time);
    // 分發計算任務 num_groups_x * num_groups_y * num_groups_z
    glDispatchCompute(PARTICLE_GROUP_COUNT, 1, 1);
 
    // 同步 計算着色器的 Invocations 
    glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
 
    // 實時改變 MVP 矩陣
    glm::mat4 projection = glm::perspective(45.0f, aspect_ratio, 0.1f, 1000.0f); 
    glm::mat4 view = glm::mat4(1.f);
    view = glm::translate(view, glm::vec3(0.0f, 0.0f, -60.0f));
    view = glm::rotate(view, time * 100.0f, glm::vec3(0.0f, 1.0f, 0.0f));
 
    glm::mat4 mvp = projection * view;
 
    // ----------------------------------------------------
    // 清屏，并切換到 渲染着色器
    glClearColor(0., 0., 0., 0.);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDisable(GL_DEPTH_TEST);
 
    glUseProgram(render_prog);
    glUniformMatrix4fv(0, 1, GL_FALSE, (const GLfloat *)&mvp[0][0]);    // 傳入 MVP 矩陣
    glBindVertexArray(render_vao);  // 綁定 VAO
 
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ONE);
    glPointSize(2.0f);
    glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT); // 圖元為 Points
 
    last_ticks = current_ticks;
 
    glutSwapBuffers();
}

計算着色器 GLSL代碼：

#define STRINGIZE(a) #a
 
const char* compute_shader_source =
STRINGIZE(
#version 430 core\n
// Uniform Block
layout(std140, binding = 0) uniform attractor_block
{
    vec4 attractor[64]; // xyz = position, w = mass
};
 
layout(local_size_x = 128) in;
 
layout(rgba32f, binding = 0) uniform imageBuffer velocity_buffer;
layout(rgba32f, binding = 1) uniform imageBuffer position_buffer;
 
uniform float dt = 1.0;
 
void main(void)
{
    // 從 TBO 中取出資料，imageLoad 和 texelFetch 相似，因為省去了 filtering 的過程是以更高效
    vec4 vel = imageLoad(velocity_buffer, int(gl_GlobalInvocationID.x));
    vec4 pos = imageLoad(position_buffer, int(gl_GlobalInvocationID.x));
 
    int i;
 
    pos.xyz += vel.xyz * dt;
    pos.w -= 0.0001 * dt;
 
    for (i = 0; i < 4; i++)
    {
        vec3 dist = (attractor[i].xyz - pos.xyz);
        vel.xyz += dt * dt * attractor[i].w * normalize(dist) / (dot(dist, dist) + 10.0);
    }
 
    if (pos.w <= 0.0)
    {
        pos.xyz = -pos.xyz * 0.01;
        vel.xyz *= 0.01;
        pos.w += 1.0f;
    }
    // 經過計算以後再寫回 TBO
    imageStore(position_buffer, int(gl_GlobalInvocationID.x), pos); // 類似的還有 imageSize
    imageStore(velocity_buffer, int(gl_GlobalInvocationID.x), vel);
}
);

注：

1）

gl_WorkGroupSize：存儲 local workgroup 的大小（三維）

gl_NumWorkGroups：存儲了組在三個次元上的個數

gl_LocalInvocationID：目前 Invocation 在 local workgroup 中的位置（三維）

範圍在 [uvec3(0), gl_WorkGroupSize - uvec3(1)] 之間

gl_LocalInvocationIndex：意義同上，差別在于它是一維的

它相當于 gl_LocalInvocationID.z * gl_WorkGroupSize.x * gl_WorkGroupSize.y + gl_LocalInvocationID.y * gl_WorkGroupSize.x + gl_LocalInvocationID.x

gl_GlobalInvocationID：目前 Invocation 在 global workgroup 中的位置（三維）

它相當于 gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID

gl_WorkGroupID：目前 local workgroup 在 global workgroup 中的位置

範圍在 [uvec3(0), gl_NumWorkGroups - uvec3(1)] 之間

2）local_size_x, local_size_y, local_size_z 聲明了 local workgroup 的大小；

3）可以通過 glGetProgramiv() 搭配 GL_MAX_COMPUTE_WORK_GROUP_SIZE 查詢 Local workgroup 的大小；

4）shared 類型的變量，意味着位于同一 local workgroup 中的 Invocation 共享該變量，通常通路共享變量的性能要優于通路 image 和 shader storage buffer；

5）Invocation 的同步

barrier：同步同一個 local workgroup 的 Invocation，確定所有 Invocation 都到達 barrier 之後才能往下執行；

memoryBarrier：確定所有記憶體的寫入操作在此之前都已完成（沒有資料駐留在緩存或者計劃放入緩存）；

memoryBarrierAtomicCounter：等待所有更新原子計數器的操作完畢，才會繼續執行；

memoryBarrierBuffer/memoryBarrierImage：等待所有寫入 buffer 或 image 變量的操作都完成

memoryBarrierShared：等待所有更新 shared 變量的操作完畢，才會繼續執行

❤ 但是以上這些函數并不能確定其他 invocation 都能到達這個點，是以仍然需要 barrier

groupMemoryBarrier 是高效版的 memoryBarrier，但是 groupMemoryBarrier 僅對 local workgroup 有效，而其他的 memoryBarrer 是全局的，即 global workgroup 的寫入請求都已完成。

6）image類型（比如 imagebuffer ）可用于一般化的資料存儲。image 類型與 sampler 類型相似，有兩點差別：其一，image 類型僅表示單層的紋理，并沒有完整的 mipmap 鍊；其二，image 類型并不支援一些 sampler 操作，比如濾波（filtering）和深度比較。（注：image 類型在聲明時還需要帶上格式布局修飾符——format layout qualifier，[例如 rgba32f，具體可以參考 OpenGL 紅寶書第八版第11章 P566 ] 需要和 glBindImageTexture 中的類型一緻）

相關資料：

【OpenGL】向Shader中傳遞資料

GLAPI/glTexBuffer

使用計算着色器（Compute Shader）模拟粒子效果【OpenGL】【GLSL】

繼續閱讀

C語言第四章自述2第四章選擇結構程式設計

面試題:vector和map的差別，異同。空間分布，100萬資料存哪個比較合适。一、疊代器差別二、vector三、Map、Set四、vector_map 為什麼比map效率高五、如何選擇六、容器選擇原則七、效率對比

C++ 多線程用條件變量确定線程的執行順序而不是使用 sleep(1)

POJ 1284 Primitive Roots (歐拉函數&原根定理)

CQ V1.0分詞bates(基于雙數組tire樹)—應該是目前最快的中文分詞算法

成員函數初始化清單

2021-08-13c++——類之操作符重載

swmm與lisflood-fp源碼如何一起編譯 CMake指令

Windows下VS開發環境環境安裝工程項目設定關于Debug和Release的提示

一文看懂字元串的加減乘除

C++ 第十五周報告1--《冒泡法排序》

C++實作簡單順序表

C經典書籍筆記——C陷阱與缺陷②(文法陷阱之優先級)一、錯誤案列二、優先級規律

線性表之順序表的實作

C++判斷素數、求最大公約數代碼判斷一個數是否為素數求兩個數的最大公約數

SequoiaDB巨杉資料庫C++驅動概述