Spiral Galaxy GPU Particle System

설치 방법

1. 폴더 구조

Assets/
└── SpiralGalaxy/
    ├── SpiralGalaxySystem.cs          ← C# 스크립트
    ├── Resources/
    │   └── SpiralGalaxyCompute.compute  ← ★ Resources 폴더 필수
    └── Shaders/
        └── SpiralGalaxy.shader

주의: SpiralGalaxyCompute.compute 는 반드시 Resources/ 폴더 안에 있어야 합니다.
SpiralGalaxy.shader 는 어느 폴더에 있어도 무방합니다 (Shader.Find 로 이름 검색).

---

2. 씬 세팅

1. 빈 GameObject 생성 (Create Empty)
2. SpiralGalaxySystem 컴포넌트 추가
3. 끝 — Inspector 에서 Compute/Shader/Material 을 드래그할 필요 없음

---

3. 에디터에서 바로 보기

• [ExecuteAlways] 가 선언되어 있어 Play 없이 Scene/Game 뷰에서 즉시 렌더링됩니다.
• Inspector 의 파라미터를 조정하면 OnValidate → Cleanup → Initialize 순서로 재초기화됩니다.

---

4. Inspector 파라미터

파라미터	기본값	설명
Particle Count	500,000	파티클 수 (GPU 메모리 주의)
Galaxy Radius	40	은하 반지름 (Unit)
Spiral Tightness	0.35	나선 감기 정도
Arm Count	4	나선팔 수
Arm Width	0.25	나선팔 두께 (0~1)
Disk Thickness	0.08	원반 수직 두께 비율
Rotation Speed	4	회전 속도 (Play 모드)
Particle Size Min/Max	0.04 / 0.18	파티클 크기 범위
Brightness Boost	1.2	전체 밝기 배율

---

5. 카메라 권장 설정

• Background: Solid Color → 완전한 검정 (0,0,0,0)
• Clear Flags: Solid Color
• 위에서 약 45° 내려다보는 각도 (예: Position(0, 60, -60), Rotation(45, 0, 0))

---

6. 렌더 파이프라인 주의사항

이 셰이더는 Built-in Render Pipeline 기준입니다.

URP 사용 시 SpiralGalaxy.shader 의 Pass 블록을 아래와 같이 수정하세요:

Tags { "LightMode" = "UniversalForward" }

그리고 UnityCG.cginc → Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl 로 교체합니다.

---

7. 트러블슈팅

증상	원인	해결
SpiralGalaxyCompute.compute 를 찾을 수 없습니다	Resources 폴더 미존재	Resources/ 폴더 안에 .compute 파일 배치
Shader 'SpiralGalaxy/Particle' 를 찾을 수 없습니다	Shader 이름 불일치	.shader 파일 첫 줄 Shader "SpiralGalaxy/Particle" 확인
에디터에서 아무것도 안 보임	Scene view Camera not rendering	Scene 뷰 상단 Gizmos 활성화, Game 뷰 확인
파티클이 흰색 사각형으로 표시됨	Shader compile 오류	Console 창 오류 확인, #pragma target 4.5 지원 GPU 여부 확인

---

Code

SpiralGalaxySystem.cs

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

/// 폴더 구조:
///   Assets/SpiralGalaxy/
///     ├── SpiralGalaxySystem.cs
///     ├── Resources/
///     │   └── SpiralGalaxyCompute.compute
///     └── Shaders/
///         └── SpiralGalaxy.shader

[ExecuteAlways]
public class SpiralGalaxySystem : MonoBehaviour
{
    [Header("Particle Settings")]
    public int particleCount = 500000;

    [Header("Galaxy Shape")]
    public float galaxyRadius    = 40f;
    public float spiralTightness = 0.35f;
    public int   armCount        = 4;
    public float armWidth        = 0.25f;
    public float diskThickness   = 0.08f;

    [Header("Animation")]
    public float rotationSpeed   = 4f;

    [Header("Visuals")]
    public float particleSizeMin = 0.04f;
    public float particleSizeMax = 0.18f;
    public float brightnessBoost = 1.2f;

    // ── 내부 상태 ─────────────────────────────────────────────────
    ComputeShader _compute;
    Material      _material;
    Mesh          _mesh;
    ComputeBuffer _particleBuffer;

    int  _kernelInit;
    int  _kernelUpdate;
    int  _threadGroups;
    bool _initialized;

    // position(float3) + velocity(float3) + size(float) + color(float4) = 11 floats = 44 bytes
    const int PARTICLE_STRIDE = 11 * sizeof(float);

    // ─────────────────────────────────────────────────────────────
    void OnEnable()  => Initialize();
    void OnDisable() => Cleanup();

    // ─────────────────────────────────────────────────────────────
    void Initialize()
    {
        if (_initialized) return;

        // ── 1. ComputeShader (Resources 폴더 필수) ────────────────
        if (_compute == null)
        {
            _compute = Resources.Load<ComputeShader>("SpiralGalaxyCompute");
            if (_compute == null)
            {
                Debug.LogError("[SpiralGalaxy] Resources/SpiralGalaxyCompute.compute 없음");
                return;
            }
        }

        // ── 2. Shader → Material ──────────────────────────────────
        if (_material == null)
        {
            var shader = Shader.Find("SpiralGalaxy/Particle");
            if (shader == null)
            {
                Debug.LogError("[SpiralGalaxy] Shader 'SpiralGalaxy/Particle' 없음");
                return;
            }
            _material = new Material(shader) { hideFlags = HideFlags.HideAndDontSave };
        }

        // ── 3. Quad Mesh 직접 생성 (CreatePrimitive 없음) ─────────
        if (_mesh == null)
            _mesh = CreateQuadMesh();

        // ── 4. 커널 인덱스 ────────────────────────────────────────
        _kernelInit   = _compute.FindKernel("Initialize");
        _kernelUpdate = _compute.FindKernel("Update");

        // ── 5. ComputeBuffer ──────────────────────────────────────
        _particleBuffer = new ComputeBuffer(particleCount, PARTICLE_STRIDE);

        // ── 6. 버퍼 바인딩 ────────────────────────────────────────
        _compute.SetBuffer(_kernelInit,   "particles", _particleBuffer);
        _compute.SetBuffer(_kernelUpdate, "particles", _particleBuffer);
        _material.SetBuffer("particles",               _particleBuffer);

        // ── 7. 파라미터 → Initialize 커널 실행 ───────────────────
        UploadShapeParams();
        _threadGroups = Mathf.CeilToInt(particleCount / 256f);
        _compute.Dispatch(_kernelInit, _threadGroups, 1, 1);

        _initialized = true;
    }

    // ─────────────────────────────────────────────────────────────
    void Update()
    {
        if (!_initialized) Initialize();
        if (!_initialized) return;

        if (Application.isPlaying)
        {
            _compute.SetFloat("deltaTime",     Time.deltaTime);
            _compute.SetFloat("time",          Time.time);
            _compute.SetFloat("rotationSpeed", rotationSpeed);
            _compute.Dispatch(_kernelUpdate, _threadGroups, 1, 1);
        }

        _material.SetFloat("_BrightnessBoost", brightnessBoost);
        Render();
    }

    // ─────────────────────────────────────────────────────────────
    void Render()
    {
        if (_mesh == null || _material == null || _particleBuffer == null) return;

        Graphics.DrawMeshInstancedProcedural(
            _mesh,
            0,
            _material,
            new Bounds(Vector3.zero, Vector3.one * galaxyRadius * 3f),
            particleCount
        );
    }

    // ─────────────────────────────────────────────────────────────
    void UploadShapeParams()
    {
        _compute.SetFloat("galaxyRadius",    galaxyRadius);
        _compute.SetFloat("spiralTightness", spiralTightness);
        _compute.SetFloat("armWidth",        armWidth);
        _compute.SetFloat("diskThickness",   diskThickness);
        _compute.SetFloat("particleSizeMin", particleSizeMin);
        _compute.SetFloat("particleSizeMax", particleSizeMax);
        _compute.SetInt("particleCount",     particleCount);
        _compute.SetInt("armCount",          armCount);
    }

    // ─────────────────────────────────────────────────────────────
    void Cleanup()
    {
        _particleBuffer?.Release();
        _particleBuffer = null;

        SafeDestroy(_material); _material = null;
        SafeDestroy(_mesh);     _mesh     = null;

        _initialized = false;
    }

    // OnValidate 에서 DestroyImmediate 직접 호출 금지
    // → delayCall 로 현재 콜백이 끝난 뒤 재초기화
    void OnValidate()
    {
#if UNITY_EDITOR
        EditorApplication.delayCall += () =>
        {
            if (this == null) return;  // 컴포넌트가 삭제된 경우 방어
            Cleanup();
            Initialize();
        };
#endif
    }

    // ─────────────────────────────────────────────────────────────
    // CreatePrimitive + Destroy 대신 Mesh 직접 생성
    // ─────────────────────────────────────────────────────────────
    static Mesh CreateQuadMesh()
    {
        var m = new Mesh
        {
            name      = "GalaxyQuad",
            hideFlags = HideFlags.HideAndDontSave
        };
        m.vertices = new[]
        {
            new Vector3(-0.5f, -0.5f, 0f),
            new Vector3( 0.5f, -0.5f, 0f),
            new Vector3( 0.5f,  0.5f, 0f),
            new Vector3(-0.5f,  0.5f, 0f),
        };
        m.uv = new[]
        {
            new Vector2(0f, 0f),
            new Vector2(1f, 0f),
            new Vector2(1f, 1f),
            new Vector2(0f, 1f),
        };
        m.triangles = new[] { 0, 2, 1,  0, 3, 2 };
        m.RecalculateNormals();
        return m;
    }

    // ─────────────────────────────────────────────────────────────
    // 에디터/런타임 공통 안전 삭제
    // ─────────────────────────────────────────────────────────────
    static void SafeDestroy(Object obj)
    {
        if (obj == null) return;
#if UNITY_EDITOR
        if (!Application.isPlaying)
            DestroyImmedi...

<...etc...>

---

SpiralGalaxyCompute.compute

// SpiralGalaxyCompute.compute
// 위치: Assets/SpiralGalaxy/Resources/SpiralGalaxyCompute.compute
//
// Particle stride = 11 floats = 44 bytes
//   float3 position (0~11)
//   float3 velocity (12~23)
//   float  size     (24~27)
//   float4 color    (28~43)

#pragma kernel Initialize
#pragma kernel Update

struct Particle
{
    float3 position;
    float3 velocity;
    float  size;
    float4 color;
};

RWStructuredBuffer<Particle> particles;

// ── Galaxy shape params ──────────────────────────────────────────
float galaxyRadius;
float spiralTightness;
float armWidth;
float diskThickness;
float particleSizeMin;
float particleSizeMax;
int   particleCount;
int   armCount;

// ── Animation params ─────────────────────────────────────────────
float rotationSpeed;
float deltaTime;
float time;

// ────────────────────────────────────────────────────────────────
// Hash functions (integer-based, no stdlib 의존 없음)
// ────────────────────────────────────────────────────────────────
uint hash1(uint n)
{
    n = (n ^ 61u) ^ (n >> 16u);
    n *= 9u;
    n = n ^ (n >> 4u);
    n *= 0x27d4eb2du;
    n = n ^ (n >> 15u);
    return n;
}

float rand(uint seed)
{
    return float(hash1(seed) & 0x00FFFFFFu) / float(0x01000000u);
}

// Box-Muller: 가우시안 분포 (평균 0, 표준편차 1)
float2 randGaussian(uint seed)
{
    float u1 = max(rand(seed * 1664525u + 1013904223u), 1e-6);
    float u2 = rand(seed * 22695477u + 1u);
    float mag = sqrt(-2.0 * log(u1));
    float phi = 6.28318530718 * u2;
    return float2(mag * cos(phi), mag * sin(phi));
}

// ────────────────────────────────────────────────────────────────
// Initialize 커널
// ────────────────────────────────────────────────────────────────
[numthreads(256, 1, 1)]
void Initialize(uint3 id : SV_DispatchThreadID)
{
    uint i = id.x;
    if ((int)i >= particleCount) return;

    // ── 나선팔 선택 ──────────────────────────────────────────────
    int   arm       = (int)(i % (uint)armCount);
    float armAngle  = (float)arm / (float)armCount * 6.28318530718;

    // ── 반지름: 지수 분포 (중심에 집중, 외곽으로 희미해짐) ────────
    float r_raw = rand(hash1(i * 3u + 0u));
    // pow(x, 0.6)으로 중간 반지름대 밀도 강화
    float r     = pow(r_raw, 0.6) * galaxyRadius;

    // ── 나선 각도 = 나선팔 위상 + 나선 감기 + 팔 내 분산 ─────────
    float spiralAngle = r * spiralTightness * 6.28318530718;

    // 팔 내 각도 분산 (가우시안)
    float2 g     = randGaussian(hash1(i * 7u + 1u));
    float scatter = g.x * armWidth * (1.0 + r / galaxyRadius); // 외곽일수록 퍼짐

    float theta  = armAngle + spiralAngle + scatter;

    // ── 위치 계산 ─────────────────────────────────────────────────
    float x = r * cos(theta);
    float z = r * sin(theta);

    // 수직 방향: 중심은 두껍고 외곽은 얇은 원반
    float yScale = galaxyRadius * diskThickness * (1.0 - r / galaxyRadius * 0.7);
    float y      = g.y * yScale;

    particles[i].position = float3(x, y, z);
    particles[i].velocity = float3(0, 0, 0);

    // ── 파티클 크기 ───────────────────────────────────────────────
    float sizeFactor = rand(hash1(i * 11u + 3u));
    // 중심부에 약간 더 큰 입자 배치
    float coreBoost  = exp(-r / (galaxyRadius * 0.3)) * 0.5;
    particles[i].size = lerp(particleSizeMin, particleSizeMax, sizeFactor + coreBoost);

    // ── 색상: 중심(청백) → 중간(따뜻한 흰색) → 외곽(적갈색/희미) ──
    float t = r / galaxyRadius; // 0 = 중심, 1 = 외곽

    // 나선팔 위에 있는지 판별 (팔 각도와의 거리)
    float onArm = saturate(1.0 - abs(scatter) / (armWidth * 2.0));

    float4 coreColor   = float4(0.55, 0.80, 1.00, 1.0);   // 차가운 청백
    float4 midColor    = float4(1.00, 0.95, 0.80, 1.0);   // 따뜻한 흰색
    float4 outerColor  = float4(0.90, 0.45, 0.20, 0.5);   // 붉은빛, 희미

    float4 col;
    if (t < 0.4)
        col = lerp(coreColor, midColor, t / 0.4);
    else
        col = lerp(midColor,  outerColor, (t - 0.4) / 0.6);

    // 나선팔 바깥 입자는 더 희미하게
    col.a *= lerp(0.3, 1.0, onArm);
    // 중심으로 갈수록 밝게
    col.a *= lerp(0.5, 1.0, 1.0 - t * 0.8);
    // 외곽 페이드아웃
    col.a *= saturate(1.0 - t * t);

    particles[i].color = col;
}

// ────────────────────────────────────────────────────────────────
// Update 커널 (Play 모드에서만 호출됨)
// 차등 회전 (Differential rotation): 내부가 더 빠르게 회전
// ────────────────────────────────────────────────────────────────
[numthreads(256, 1, 1)]
void Update(uint3 id : SV_DispatchThreadID)
{
    uint i = id.x;
    if ((int)i >= particleCount) return;

    float3 pos = particles[i].position;

    // XZ 평면 반지름
    float r = length(float2(pos.x, pos.z));

    // 케플러식 차등 회전: 중심 근처는 빠르고, 외곽은 느림
    // v ∝ 1 / sqrt(r + epsilon) 를 근사
    float keplerian = rotationSpeed / sqrt(max(r * 0.4 + 0.5, 0.01));

    float angle  = keplerian * deltaTime;
    float cosA   = cos(angle);
    float sinA   = sin(angle);

    float newX = pos.x * cosA - pos.z * sinA;
    float newZ = pos.x * sinA + pos.z * cosA;

    particles[i].position = float3(newX, pos.y, newZ);
}

---

SpiralGalaxy.shader

// 위치: Assets/SpiralGalaxy/Shaders/SpiralGalaxy.shader
Shader "SpiralGalaxy/Particle"
{
    Properties
    {
        _BrightnessBoost ("Brightness Boost", Float) = 1.2
    }

    SubShader
    {
        Tags
        {
            "Queue"           = "Transparent"
            "RenderType"      = "Transparent"
            "IgnoreProjector" = "True"
        }

        Pass
        {
            Blend  One One      // Additive: 파티클 누적 = 성운 효과
            ZWrite Off
            ZTest  LEqual
            Cull   Off
            Lighting Off

            CGPROGRAM
            #pragma vertex   vert
            #pragma fragment frag
            #pragma target   4.5
            // DrawMeshInstancedProcedural 에 필수
            #pragma multi_compile_instancing
            #pragma instancing_options procedural:setup

            #include "UnityCG.cginc"

            // ── Particle 구조체 (C# PARTICLE_STRIDE = 44 bytes 와 동일) ──
            struct Particle
            {
                float3 position;   // 12 bytes
                float3 velocity;   // 12 bytes
                float  size;       //  4 bytes
                float4 color;      // 16 bytes
            };

            StructuredBuffer<Particle> particles;
            float _BrightnessBoost;

            // procedural instancing setup 함수 (빈 함수여도 선언 필요)
            void setup() {}

            struct appdata
            {
                float4 vertex   : POSITION;
                float2 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f
            {
                float4 pos   : SV_POSITION;
                float2 uv    : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                UNITY_SETUP_INSTANCE_ID(v);

                // unity_InstanceID: DrawMeshInstancedProcedural 에서
                // SV_InstanceID 가 자동으로 이 변수에 저장됨
                Particle p = particles[unity_InstanceID];

                // ── 빌보드: View Matrix 의 각 행 = 카메라 로컬 축(월드 기준)
                //
                // UNITY_MATRIX_V (View Matrix) 행 구조:
                //   [0].xyz = 카메라 Right  (월드 공간)
                //   [1].xyz = 카메라 Up     (월드 공간)
                //   [2].xyz = 카메라 Back   (월드 공간, -Forward)
                //
                // 주의: UNITY_MATRIX_V[row][col] 에서
                //   UNITY_MATRIX_V[0].xyz 가 올바른 행 접근법
                //   UNITY_MATRIX_V[0][0], [1][0], [2][0] 은 열 0의 각 성분으로
                //   Right/Up/Back 이 아니라 잘못된 벡터가 됨 ← 이전 버전의 버그
                float3 camRight = UNITY_MATRIX_V[0].xyz;
                float3 camUp    = UNITY_MATRIX_V[1].xyz;

                // Quad UV 는 0~1 범위, 중심 기준 -0.5~0.5 로 오프셋 변환
                float2 offset   = v.texcoord.xy - 0.5;
                float3 worldPos = p.position
                                + camRight * (offset.x * p.size)
                                + camUp    * (offset.y * p.size);

                v2f o;
                o.pos   = UnityWorldToClipPos(worldPos);
                o.uv    = v.texcoord.xy;
                o.color = p.color * _BrightnessBoost;
                return o;
            }

            float4 frag(v2f i) : SV_Target
            {
                // Gaussian falloff: 중심이 밝고 가장자리는 부드럽게 0으로
                float2 uv    = i.uv * 2.0 - 1.0;    // -1 ~ 1
                float  dist2 = dot(uv, uv);           // |uv|^2

                float alpha = exp(-dist2 * 3.5);

                // 거의 투명한 파티클 조기 폐기 (fillrate 절약)
                clip(alpha * i.color.a - 0.002);

                float4 col = i.color;
                col.rgb *= alpha;
                col.a    = alpha * i.color.a;
                return col;
            }
            ENDCG
        }
    }

    FallBack Off
}

---