🫧Art_015 Noise Field Sphere

0. 폴더 구조

편의를 위해 아래와 같이 Assets 아래에 Scripts 폴더와 Shaders 폴더를 만들어 관리합니다.
Scirpts 폴더는 필요에 따라 하위 폴더를 만들어서 C# 스크립트를 넣어 놓습니다.

Assets
 ├─ Scripts
 │   └─ Artworks
 │       └─ Art_015_NoiseFieldSphere.cs
 │
 ├─ Shaders
 │   └─ GPUInstancedParticles.shader

1. GameObject 생성

Hierarchy > Create Empty (Ctrl + Shift + N)

이렇게 만든 GameObject의 이름을 바꾸거나 그대로 사용해도 무방합니다.
여기에 C# 스크립트를 컴포넌트로 부착하면 됩니다.

아래의 코드 구조를 사용하면

GameObject 수 = 1
↓
Sphere Mesh 하나만 사용
↓
Graphics.DrawMeshInstanced()
↓
GPU에서 수천 개 인스턴스 렌더링

이렇게 아트워크를 보여주는 것이 가능합닏다.

2. Shader 파일 생성

위에서 만든 Shaders 폴더로 이동
Project Window > Create > Shader > URP Unlit Shader

새로운 셰이더 파일이 NewUnlitUniversalRenderPipelineShader라는 이름으로 만들어집니다.
이름은 아트워크에 어울리게 GPUInstancedParticles로 바꾸어 줍니다. 이후 이 파일은 C# 스크립트에서 연결됩니다. 기본으로 작성된 코드를 지우고 아래의 셰이더 스크립트로 교체합니다.

3. Script 작성

📄Art_015_NoiseFieldSphere.cs

using UnityEngine;

[ExecuteAlways]
public class Art_015_NoiseFieldSphere : MonoBehaviour
{
    [Header("Particle Count")]
    public int particleCount = 100000;

    [Header("Field Radius")]
    public float radius = 15f;

    [Header("Motion")]
    public float flowScale = 0.35f;
    public float flowStrength = 6f;
    public float curlStrength = 2f;
    public float motionSpeed = 0.3f;

    [Header("Particle Size")]
    public float sizeMin = 0.05f;
    public float sizeMax = 0.25f;

    [Header("Color Field")]
    public Gradient gradient;

    public Mesh mesh;
    public Material material;

    ComputeBuffer particleBuffer;
    ComputeBuffer argsBuffer;

    struct Particle
    {
        public Vector3 pos;
        public float size;
        public Vector4 color;
    }

    Particle[] particles;

    uint[] args = new uint[5];

    bool initialized = false;

    void OnEnable()
    {
        Initialize();
    }

    void OnDisable()
    {
        Release();
    }

    void Initialize()
    {
        if (initialized) return;

        CreateGradient();
        CreateMesh();
        CreateMaterial();

        particles = new Particle[particleCount];

        for (int i = 0; i < particleCount; i++)
        {
            Vector3 p = Random.insideUnitSphere * radius;

            float size = Random.Range(sizeMin, sizeMax);

            float t = p.magnitude / radius;
            Color col = gradient.Evaluate(t);

            particles[i].pos = p;
            particles[i].size = size;
            particles[i].color = col;
        }

        particleBuffer = new ComputeBuffer(
            particleCount,
            sizeof(float) * 8
        );

        particleBuffer.SetData(particles);

        args[0] = mesh.GetIndexCount(0);
        args[1] = (uint)particleCount;
        args[2] = mesh.GetIndexStart(0);
        args[3] = mesh.GetBaseVertex(0);

        argsBuffer = new ComputeBuffer(
            1,
            args.Length * sizeof(uint),
            ComputeBufferType.IndirectArguments
        );

        argsBuffer.SetData(args);

        material.SetBuffer("_Particles", particleBuffer);

        initialized = true;
    }

    void CreateGradient()
    {
        if (gradient != null) return;

        gradient = new Gradient();

        GradientColorKey[] ck = new GradientColorKey[3];

        ck[0] = new GradientColorKey(
            new Color(0.2f,0.3f,1f),
            0f
        );

        ck[1] = new GradientColorKey(
            new Color(0f,1f,0.8f),
            0.5f
        );

        ck[2] = new GradientColorKey(
            new Color(1f,0.2f,1f),
            1f
        );

        GradientAlphaKey[] ak = new GradientAlphaKey[2];

        ak[0] = new GradientAlphaKey(1,0);
        ak[1] = new GradientAlphaKey(1,1);

        gradient.SetKeys(ck,ak);
    }

    void CreateMesh()
    {
        if (mesh != null) return;

        GameObject g =
            GameObject.CreatePrimitive(
                PrimitiveType.Sphere
            );

        mesh =
            g.GetComponent<MeshFilter>()
            .sharedMesh;

        DestroyImmediate(g);
    }

    void CreateMaterial()
    {
        if (material != null) return;

        Shader shader =
            Shader.Find("Custom/GPUInstancedParticles");

        material = new Material(shader);
        material.enableInstancing = true;
    }

    void Update()
    {
        if (!initialized) return;

        if (!Application.isPlaying)
        {
            Render();
            return;
        }

        AnimateParticles();

        particleBuffer.SetData(particles);

        Render();
    }

    void AnimateParticles()
    {
        float t = Time.time * motionSpeed;

        for (int i = 0; i < particleCount; i++)
        {
            Vector3 p = particles[i].pos;

            Vector3 flow =
                FlowNoise(
                    p * flowScale +
                    Vector3.one * t
                );

            Vector3 curl =
                CurlNoise(
                    p * flowScale +
                    Vector3.one * t
                );

            p += flow * flowStrength * Time.deltaTime;
            p += curl * curlStrength * Time.deltaTime;

            if (p.magnitude > radius)
                p = p.normalized * radius;

            particles[i].pos = p;

            float d = p.magnitude / radius;

            particles[i].color =
                gradient.Evaluate(d);
        }
    }

    Vector3 FlowNoise(Vector3 p)
    {
        float nx = Mathf.PerlinNoise(p.y,p.z);
        float ny = Mathf.PerlinNoise(p.z,p.x);
        float nz = Mathf.PerlinNoise(p.x,p.y);

        return new Vector3(nx,ny,nz) - Vector3.one*0.5f;
    }

    Vector3 CurlNoise(Vector3 p)
    {
        float e = 0.1f;

        float nx1 = Mathf.PerlinNoise(p.y,p.z+e);
        float nx2 = Mathf.PerlinNoise(p.y,p.z-e);

        float ny1 = Mathf.PerlinNoise(p.z,p.x+e);
        float ny2 = Mathf.PerlinNoise(p.z,p.x-e);

        float nz1 = Mathf.PerlinNoise(p.x,p.y+e);
        float nz2 = Mathf.PerlinNoise(p.x,p.y-e);

        float x = ny1-ny2 - (nz1-nz2);
        float y = nz1-nz2 - (nx1-nx2);
        float z = nx1-nx2 - (ny1-ny2);

        return new Vector3(x,y,z);
    }

    void Render()
    {
        Graphics.DrawMeshInstancedIndirect(
            mesh,
            0,
            material,
            new Bounds(
                Vector3.zero,
                Vector3.one * radius * 4
            ),
            argsBuffer
        );
    }

    void Release()
    {
        if (particleBuffer != null)
            particleBuffer.Release();

        if (argsBuffer != null)
            argsBuffer.Release();
    }
}

📄GPUInstancedParticles.shader

Shader "Custom/GPUInstancedParticles"
{
    SubShader
    {
        Pass
        {
            CGPROGRAM

            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_instancing

            #include "UnityCG.cginc"

            struct Particle
            {
                float3 pos;
                float size;
                float4 color;
            };

            StructuredBuffer<Particle> _Particles;

            struct appdata
            {
                float3 vertex : POSITION;
                uint instanceID : SV_InstanceID;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float4 col : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;

                Particle p =
                    _Particles[v.instanceID];

                float3 world =
                    v.vertex * p.size + p.pos;

                o.pos =
                    UnityObjectToClipPos(
                        float4(world,1)
                    );

                o.col = p.color;

                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                return i.col;
            }

            ENDCG
        }
    }
}

4. Post Processing

파티클이 생성된 Scene에 Bloom, Color Adjustment, Depth of Field 등을 적용하여 꾸밀 수 있습니다.
렌더링이 끝난 후 화면에 후처리를 하는 것이고 코드로도 작성이 가능하나 GUI에서 조정하며 바로 결과를 보는 편이 효율적입니다.
먼저 Global Volume을 생성합니다.

Hierarchy > 우클릭 > Volume > Global Volume

Inspector 창에서 각종 수치 조정을 하며, 추가로 필요한 기능이 있으면 Add Override을 눌러 Post-processing 항목 중에서 고르면 됩니다.

참고로 이 Volume 설정은 Camera의 Inspector에서 Rendering > Post Processing이 체크되어야지 적용됩니다.