《GPU 粒子与特效系统：计算着色器、Transform Feedback 与十万级粒子》

// C++：CPU 粒子的典型更新循环
void UpdateCPUParticles(float dt) {
    for (auto& p : particles) {
        if (!p.alive) continue;
        p.velocity += gravity * dt;           // 重力
        p.velocity *= pow(damping, dt);       // 阻尼
        p.position += p.velocity * dt;        // 积分
        p.life -= dt;
        if (p.life <= 0.0f) p.alive = false;
    }
}

// HLSL：SoA 布局，各属性独立缓冲
struct ParticleBuffers {
    RWStructuredBuffer<float3> position;   // 位置
    RWStructuredBuffer<float3> velocity;   // 速度
    RWStructuredBuffer<float4> color;      // 颜色
    RWStructuredBuffer<float>  life;       // 剩余寿命
    RWStructuredBuffer<float>  size;       // 大小
    RWStructuredBuffer<uint>   aliveIndex; // 存活索引（压缩）
};

// AoS 布局（对比）：交错存储，访存跨步大
struct Particle { float3 pos; float3 vel; float4 color; float life; };
// RWStructuredBuffer<Particle> particles;  // 不推荐用于大规模

// HLSL：粒子模拟 compute shader
[numthreads(256, 1, 1)]
void SimulateParticles(uint3 id : SV_DispatchThreadID) {
    uint i = id.x;
    if (i >= particleCount) return;

    float dt = deltaTime;
    float3 pos = position[i];
    float3 vel = velocity[i];
    float  l   = life[i];

    if (l <= 0.0f) {
        // 死亡：从存活列表移除（用压缩/标记，稍后 compact）
        aliveIndex[i] = 0xFFFFFFFF;
        return;
    }

    // 力累加：重力 + 风 + 湍流
    float3 force = gravity;
    force += wind * windStrength;
    force += curlNoise(pos * noiseScale) * turbulence;

    vel += force * dt;
    vel *= exp(-drag * dt);          // 空气阻力
    pos += vel * dt;                 // 显式欧拉（或用 RK4）

    l -= dt;
    position[i] = pos;
    velocity[i] = vel;
    life[i]     = l;
    aliveIndex[i] = i;               // 标记存活
}

// HLSL：用 InterlockedAdd 压缩存活粒子
RWStructuredBuffer<uint> drawIndices;
RWByteAddressBuffer drawArgs;      // IndirectArgs

[numthreads(256,1,1)]
void CompactAlive(uint3 id : SV_DispatchThreadID) {
    uint i = id.x;
    if (life[i] <= 0.0f) return;
    uint slot;
    drawIndices.InterlockedAdd(counterOffset, 1, slot);  // 原子分配
    drawIndices[slot] = i;
}

// GLSL：Transform Feedback 粒子更新
#version 430 core
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inVelocity;
layout(location = 2) in float inLife;

out vec3 outPosition;
out vec3 outVelocity;
out float outLife;

uniform float dt;
uniform vec3 gravity;

void main() {
    vec3 vel = inVelocity + gravity * dt;
    vec3 pos = inPosition + vel * dt;
    float life = inLife - dt;

    outPosition = pos;
    outVelocity = vel;
    outLife = life;
    gl_Position = vec4(0.0);   // 不实际渲染，仅用于 TF
}

// C++：绑定 Transform Feedback（OpenGL）
glEnable(GL_RASTERIZER_DISCARD);       // 关闭光栅化，只跑 TF
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfbo);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particleBufferNext);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, particleCount);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
// 双缓冲交换：particleBufferNext ↔ particleBufferCurrent

// HLSL：Bitonic sort 的一步（简化）
[numthreads(256,1,1)]
void BitonicSortStep(uint3 id : SV_DispatchThreadID) {
    uint i = id.x;
    uint j = i ^ stage;                    // 比较伙伴
    if (j <= i) return;                    // 每对只处理一次
    bool ascending = ((i & (stage << 1)) == 0) == (direction == 0);
    float di = depthKey[i];
    float dj = depthKey[j];
    if ((di > dj) == ascending) {          // 交换
        depthKey[i] = dj; depthKey[j] = di;
        uint ti = index[i]; index[i] = index[j]; index[j] = ti;
    }
}

// GLSL：软粒子，靠近不透明几何时淡出
float softParticleFade(float sceneDepth, float particleDepth, float fadeDist) {
    float diff = sceneDepth - particleDepth;
    return saturate(diff / fadeDist);
}

[Emitter] → [Spawn Rate] → [Initialize Particle] → [Update Particle] → [Render]
                                ↑                        ↑
                           [Random Velocity]        [Gravity Force]
                                                     [Curl Noise Force]
                                                     [Collision]

// C++：异步回读粒子事件
struct FParticleEvent { uint32 Type; uint32 ParticleID; float3 Position; };
// 1. Compute 写入 eventBuffer
// 2. CopyResource 到 staging buffer
// 3. 若干帧后 Map 读取（避免 stall）

// C++：间接绘制调用
struct FDrawArgs {
    uint32 VertexCountPerInstance;  // 4（billboard 四边形）
    uint32 InstanceCount;           // 由 GPU 写入
    uint32 StartVertexLocation;
    uint32 StartInstanceLocation;
};
// GPU: 把存活数写入 InstanceCount
// CPU: DrawInstancedIndirect(argsBuffer, 0)

// GLSL：Curl Noise（由势函数求旋度，保证无散度）
vec3 curlNoise(vec3 p) {
    const float e = 0.1;
    // 势函数三通道在 ±e 处的差分，构成旋度
    vec3 dx = vec3(e, 0, 0), dy = vec3(0, e, 0), dz = vec3(0, 0, e);
    float x = potential(p + dy).z - potential(p - dy).z
            - potential(p + dz).y + potential(p - dz).y;
    float y = potential(p + dz).x - potential(p - dz).x
            - potential(p + dx).z + potential(p + dx).z;
    return normalize(vec3(x, y, 0.0) / (2.0 * e));
}

// C++：拖尾的历史位置环形缓冲
struct FTrailParticle {
    static constexpr int HistoryCount = 8;
    float3 history[HistoryCount];   // 环形
    int    head;
};