【Unity】Compute Shader粒子效果模拟

在UE4引擎中，已经实现了GPU的粒子系统，可以快速计算数百万的粒子及其碰撞。在Unity中，可以简单的使用Compute Shader，来尝试实现GPU粒子的效果。

实现一个简单的立方体粒子效果，图片压缩的很厉害……粒子数量在6w+

第一步，我们实现一个脚本，挂在在摄像机组件上，这个脚本我们用来控制粒子的渲染。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CBufferTest : MonoBehaviour {
    public Shader shader;
    public ComputeShader computeShader;

    private ComputeBuffer offsetBuffer;
    private ComputeBuffer outputBuffer;
    private ComputeBuffer constantBuffer;
    private ComputeBuffer colorBuffer;
    private int _kernel;
    private Material material;

    public const int VertCount = 65536; //64*64*4*4 (Groups*ThreadsPerGroup)

    //We initialize the buffers and the material used to draw.
    void Start()
    {
        CreateBuffers();
        CreateMaterial();
        _kernel = computeShader.FindKernel("CSMain");
    }

    //When this GameObject is disabled we must release the buffers or else Unity complains.
    private void OnDisable()
    {
        ReleaseBuffer();
    }

    //After all rendering is complete we dispatch the compute shader and then set the material before drawing with DrawProcedural
    //this just draws the "mesh" as a set of points
    void OnPostRender()
    {
        Dispatch();

        material.SetPass(0);
        material.SetBuffer("buf_Points", outputBuffer);
        material.SetBuffer("buf_Colors", colorBuffer);
        Graphics.DrawProcedural(MeshTopology.Points, VertCount);
    }

    //To setup a ComputeBuffer we pass in the array length, as well as the size in bytes of a single element.
    //We fill the offset buffer with random numbers between 0 and 2*PI.
    void CreateBuffers()
    {
        offsetBuffer = new ComputeBuffer(VertCount, 4); //Contains a single float value (OffsetStruct)

        float[] values = new float[VertCount];
        for (int i = 0; i < VertCount; i++)
        {
            values[i] = Random.value * 2 * Mathf.PI;
        }

        offsetBuffer.SetData(values);

        constantBuffer = new ComputeBuffer(1, 4); //Contains a single element (time) which is a float
        colorBuffer = new ComputeBuffer(VertCount, 12);
        outputBuffer = new ComputeBuffer(VertCount, 12); //Output buffer contains vertices (float3 = Vector3 -> 12 bytes)
    }

    //For some reason I made this method to create a material from the attached shader.
    void CreateMaterial()
    {
        material = new Material(shader);
    }

    //Remember to release buffers and destroy the material when play has been stopped.
    void ReleaseBuffer()
    {
        constantBuffer.Release();
        offsetBuffer.Release();
        outputBuffer.Release();

        DestroyImmediate(material);
    }

    //The meat of this script, it sets the constant buffer (current time) and then sets all of the buffers for the compute shader.
    //We then dispatch 32x32x1 groups of threads of our CSMain kernel.
    void Dispatch()
    {
        constantBuffer.SetData(new[] { Time.time });

        computeShader.SetBuffer(_kernel, "cBuffer", constantBuffer);
        computeShader.SetBuffer(_kernel, "offsets", offsetBuffer);
        computeShader.SetBuffer(_kernel, "output", outputBuffer);
        computeShader.SetBuffer(_kernel, "color", colorBuffer);
        computeShader.Dispatch(_kernel, 64, 64, 1);
    }
}

第二步，实现Compute Shader，用来计算粒子的位置以及颜色。

#pragma kernel CSMain
//We define the size of a group in the x and y directions, z direction will just be one
 #define thread_group_size_x 4
 #define thread_group_size_y 4
 
 //A struct that simple holds a position
struct PositionStruct
{
    float3 pos;
};
 
//A struct containing an offset for use by Wave function
struct OffsetStruct
{
    float offset;
};
 
//A constant buffer struct that holds a time variable sent from Unity
struct CBufferStruct
{
    float t;
};
 
//We keep three buffers accessed by the kernel, a constant buffer that is the same for every computation,
//an offset buffer with a value to offset the wave, and an output buffer that is written to by the kernel
RWStructuredBuffer<CBufferStruct> cBuffer;
RWStructuredBuffer<OffsetStruct> offsets;
RWStructuredBuffer<PositionStruct> output;
RWStructuredBuffer<float3> color;
//A simple sine modulation of the z coordinate, with an offset by a random value between 0 and 2PI
float3 Wave(float3 p, int idx,uint3 id)
{
    p.x=cos(cBuffer[0].t+id.x);
    p.y=sin(cBuffer[0].t+id.y);
    p.z = sin(cBuffer[0].t + offsets[idx].offset);
    return p;
}
 float3 SetColor(float3 p,uint3 id)
 {
    p.x=abs(sin(cBuffer[0].t+id.x));
    p.y=abs(sin(cBuffer[0].t+id.y));
    p.z=abs(sin(cBuffer[0].t+id.x+id.y));
    return p;
 }
//The kernel for this compute shader, each thread group contains a number of threads specified by numthreads(x,y,z)
//We lookup the the index into the flat array by using x + y * x_stride
//The position is calculated from the thread index and then the z component is shifted by the Wave function
[numthreads(thread_group_size_x,thread_group_size_y,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    int idx = id.x + id.y * thread_group_size_x * 32;
    float spacing = 1;
 
    float3 pos = float3(id.x*spacing, id.y*spacing, id.z*spacing);
    pos = Wave(pos, idx,id);
    color[idx]=SetColor(pos,id);
    output[idx].pos = pos;
}

第三步，实现简单的V&F Shader，用于渲染像素到屏幕。

Shader "Custom/CBufferTest" {
Properties {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
SubShader {
    Tags { 
    "Queue"="Transparent" 
    "IgnoreProjector"="True" 
    "RenderType"="Transparent" 
    }
    LOD 200
    Cull Off
    blend srcAlpha one
    Pass {
      CGPROGRAM
            #pragma target 5.0
 
            #pragma vertex vert
            #pragma fragment frag
 
            #include "UnityCG.cginc"
 
            //The buffer containing the points we want to draw.
            StructuredBuffer<float3> buf_Points;
            StructuredBuffer<float3> buf_Colors;
            //A simple input struct for our pixel shader step containing a position.
            struct ps_input {
                float4 pos : SV_POSITION;
                half3 color:COLOR;
            };
 
            //Our vertex function simply fetches a point from the buffer corresponding to the vertex index
            //which we transform with the view-projection matrix before passing to the pixel program.
            ps_input vert (uint id : SV_VertexID)
            {
                ps_input o;
                float3 worldPos = buf_Points[id];
                o.color=buf_Colors[id];
                o.pos = mul (UNITY_MATRIX_VP, float4(worldPos,1.0f));

                return o;
            }
 
            //Pixel function returns a solid color for each point.
            float4 frag (ps_input i) : COLOR
            {
                return float4(i.color,0.5);
            }
 
            ENDCG
    }
        
} 
    FallBack "Diffuse"
}

可以搜索不同的几何体算法，来实现不同的效果。