🫧Art_027 Sphere Flow Particle System [게임오브젝트]

1. 개요 및 동작 원리

1. 원점 스폰 및 표면 이동 (birthDuration)

• 파티클은 생성 시 Vector3.zero(원점)에서 시작합니다.
• age / birthDuration 비율을 사용하여 0초에서 설정된 시간까지 선형 보간(Lerp)으로 표면까지 이동합니다.
• 이 기간 동안은 노이즈 흐름이 적용되지 않아, 마치 중심에서 분출되어 표면으로 안착하는 듯한 연출을 구현합니다.

2. 해류와 같은 노이즈 필드 구현

• Unity의 Mathf.PerlinNoise는 기본적으로 2D 함수입니다. 이를 3D 구 표면에서 해류처럼 흐르도록 만들기 위해 의사 3D 벡터장(Pseudo-3D Vector Field) 기법을 사용합니다.
• nx, ny, nz를 서로 다른 좌표 조합과 시간 오프셋으로 샘플링하여, 공간적으로 일관되면서도 회전 성분을 가진 벡터를 생성합니다.
• Vector3.Dot(noiseVector, normal) * normal 계산을 통해 노이즈 벡터에서 반지름 방향 성분(구 밖으로 나가는 힘)을 제거합니다. 결과적으로 파티클은 항상 구 표면에 접하는 방향(Tangent)으로만 힘을 받아 표면 위를 미끄러지듯 흐르게 됩니다.
• 마지막으로 .normalized * sphereRadius를 적용하여 위치가 구 표면에서 벗어나지 않도록 강제 구속합니다.

3. 1/n 균등 확률 및 풀링

• validPrefabs 배열의 길이 n에 대해 Random.Range(0, n)을 호출하여 각 프리팹이 정확히 1/n의 확률로 선택됩니다.
• 선택된 프리팹에 할당된 전용 풀에서만 비활성화 객체를 재사용하므로, 프리팹 타입별 메모리 지역성이 유지되고 가비지 컬렉션 부하가 최소화됩니다.

4. Inspector 권장 설정값

4. 적용 시 참고 사항

1. 프리팹 중심축 확인: 모델링 메시의 로컬 중심(pivot)이 기하학적 중심에 위치해야 표면 구속 시 기울어짐 없이 매끄럽게 움직입니다. 중심이 어긋나면 프리팹 내부에 빈 GameObject를 중심으로 잡고 메시를 하위로 배치하세요.
2. 성능 관리: maxParticles는 실제 화면에 필요로 하는 최대 개수로 설정하세요. 풀이 가득 차면 새 파티클 생성이 스킵되므로, 프레임 드롭 없이 안정적으로 동작합니다.
3. 노이즈 패턴 다양화: noiseFrequency를 낮추면 넓은 해류처럼 느리고 거대한 흐름이, 높으면 작은 소용돌이가 많이 생기는 효과를 얻을 수 있습니다. 실행 중 Inspector 에서 실시간으로 조정하며 원하는 흐름을 찾으세요.

2. 스크립트

using UnityEngine;
using System.Collections.Generic;

public class SphereFlowParticleSystem : MonoBehaviour
{
    // =========================================================
    // [Inspector 노출 변수: 프리팹 및 풀 설정]
    // =========================================================
    [Header("Prefab Settings")]
    [Tooltip("최대 5개의 프리팹을 할당할 수 있습니다. 최소 1개는 필수입니다.")]
    public GameObject[] particlePrefabs = new GameObject[5];
    public int maxParticles = 300;        // 시스템 전체에서 관리할 파티클 총 개수
    public float lifetime = 8f;           // 파티클 수명 (초)
    public float birthDuration = 1.2f;    // 원점에서 구 표면까지 도달하는 데 걸리는 시간

    // =========================================================
    // [Inspector 노출 변수: 구 표면 및 노이즈 흐름 설정]
    // =========================================================
    [Header("Sphere & Flow Settings")]
    public float sphereRadius = 5f;       // 파티클이 움직일 구의 반지름
    public float noiseFrequency = 0.6f;   // 노이즈 필드의 주파수 (값이 높을수록 흐르는 패턴이 작고 빠름)
    public float noiseStrength = 2.0f;    // 노이즈에 의한 이동력 (흐름의 세기)
    public float flowSpeed = 1.5f;        // 해류 흐름의 기본 속도
    public float flowTimeScale = 0.8f;    // 노이즈 필드의 시간 진행 속도 (클수록 패턴 변화가 빠름)

    // =========================================================
    // [Inspector 노출 변수: 회전 설정]
    // =========================================================
    [Header("Rotation Settings")]
    public bool enableRandomStartRotation = true;  // 생성 시 랜덤 초기 회전 적용
    public bool enableContinuousRotation = true;   // 지속적 자전 적용
    public Vector3 minAngularVelocity = new Vector3(-20f, -20f, -20f); // 최소 각속도
    public Vector3 maxAngularVelocity = new Vector3(20f, 20f, 20f);    // 최대 각속도

    // =========================================================
    // [Private 멤버 변수]
    // =========================================================
    private List<GameObject> validPrefabs = new List<GameObject>();
    private Dictionary<GameObject, List<ParticleData>> prefabPools = new Dictionary<GameObject, List<ParticleData>>();
    private float spawnTimer = 0f;
    
    // 파티클 데이터 구조체
    private struct ParticleData
    {
        public GameObject gameObject;         // 파티클 오브젝트
        public GameObject assignedPrefab;     // 할당된 프리팹 타입
        public Vector3 initialDirection;      // 원점에서 표면으로 향하는 초기 방향
        public Vector3 angularVelocity;       // 자전 각속도
        public float remainingLife;           // 남은 수명
        public float age;                     // 생성 후 경과 시간
        public bool isActive;                 // 활성화 상태
    }

    // =========================================================
    // [Unity LifeCycle: OnValidate]
    // =========================================================
    void OnValidate()
    {
        validPrefabs.Clear();
        foreach (var p in particlePrefabs)
        {
            if (p != null && !validPrefabs.Contains(p))
                validPrefabs.Add(p);
        }

        // 범위 보정
        if (minAngularVelocity.x > maxAngularVelocity.x) maxAngularVelocity.x = minAngularVelocity.x;
        if (minAngularVelocity.y > maxAngularVelocity.y) maxAngularVelocity.y = minAngularVelocity.y;
        if (minAngularVelocity.z > maxAngularVelocity.z) maxAngularVelocity.z = minAngularVelocity.z;
        
        if (birthDuration <= 0f) birthDuration = 0.1f;
        if (sphereRadius <= 0.1f) sphereRadius = 0.1f;
    }

    // =========================================================
    // [Unity LifeCycle: Start]
    // =========================================================
    void Start()
    {
        validPrefabs.Clear();
        foreach (var p in particlePrefabs)
        {
            if (p != null && !validPrefabs.Contains(p))
                validPrefabs.Add(p);
        }

        if (validPrefabs.Count == 0)
        {
            Debug.LogError("[SphereFlowParticleSystem] 동작하려면 최소 1개의 프리팹이 할당되어야 합니다.");
            enabled = false;
            return;
        }

        InitializePools();
    }

    // =========================================================
    // [Private Method: 풀 초기화 및 균등 분배]
    // =========================================================
    void InitializePools()
    {
        int validCount = validPrefabs.Count;
        int baseCount = maxParticles / validCount;
        int remainder = maxParticles % validCount;

        foreach (var prefab in validPrefabs)
        {
            List<ParticleData> pool = new List<ParticleData>();
            int countForPrefab = baseCount + (remainder > 0 ? 1 : 0);
            remainder--;

            for (int i = 0; i < countForPrefab; i++)
            {
                GameObject go = Instantiate(prefab, transform);
                go.SetActive(false);
                pool.Add(new ParticleData
                {
                    gameObject = go,
                    assignedPrefab = prefab,
                    initialDirection = Vector3.zero,
                    angularVelocity = Vector3.zero,
                    remainingLife = 0f,
                    age = 0f,
                    isActive = false
                });
            }
            prefabPools[prefab] = pool;
        }
    }

    // =========================================================
    // [Unity LifeCycle: Update]
    // =========================================================
    void Update()
    {
        spawnTimer += Time.deltaTime;
        if (spawnTimer >= 1f / Mathf.Max(0.1f, maxParticles / lifetime))
        {
            spawnTimer = 0f;
            SpawnParticle();
        }

        UpdateParticles();
    }

    // =========================================================
    // [Private Method: 파티클 생성 (1/n 확률)]
    // =========================================================
    void SpawnParticle()
    {
        if (validPrefabs.Count == 0) return;

        // 1/n 균등 확률로 프리팹 선택
        GameObject selectedPrefab = validPrefabs[Random.Range(0, validPrefabs.Count)];
        List<ParticleData> targetPool = prefabPools[selectedPrefab];
        ParticleData? target = null;

        // 해당 풀에서 비활성화된 파티클 탐색
        for (int i = 0; i < targetPool.Count; i++)
        {
            if (!targetPool[i].isActive)
            {
                target = targetPool[i];
                break;
            }
        }

        // 풀이 가득 찬 경우 경고 후 스킵 (성능 안정화를 위해 런타임 생성 방지)
        if (target == null) return;

        ParticleData p = target.Value;
        Transform t = p.gameObject.transform;

        // 원점 스폰 및 초기 방향 설정
        t.position = Vector3.zero;
        p.initialDirection = Random.onUnitSphere; // 표면으로 향할 방향 저장
        
        // 랜덤 각속도 설정
        p.angularVelocity = new Vector3(
            Random.Range(minAngularVelocity.x, maxAngularVelocity.x),
            Random.Range(minAngularVelocity.y, maxAngularVelocity.y),
            Random.Range(minAngularVelocity.z, maxAngularVelocity.z)
        );

        // 초기 회전 적용
        t.rotation = enableRandomStartRotation ? Random.rotationUniform : Quaternion.identity;

        // 상태 초기화
        p.remainingLife = lifetime;
        p.age = 0f;
        p.isActive = true;
        p.gameObject.SetActive(true);

        // 풀 데이터 갱신
        int idx = targetPool.IndexOf(target.Value);
        targetPool[idx] = p;
    }

    // =========================================================
    // [Private Method: 파티클 업데이트 (노이즈 필드 + 표면 구속)]
    // =========================================================
    void UpdateParticles()
    {
        float dt = Time.deltaTime;
        float currentTime = Time.time * flowTimeScale;

        foreach (var pool in prefabPools.Values)
        {
            for (int i = 0; i < pool.Count; i++)
            {
                if (!pool[i].isActive) continue;

                ParticleData p = pool[i];
                Transform t = p.gameObject.transform;

                // 수명 및 경과 시간 업데이트
                p.age += dt;
                p.remainingLife -= dt;

                // -------------------------------------------------
                // [1. 출생 애니메이션: 원점 -> 구 표면 이동]
                // -------------------------------------------------
                float birthProgress = Mathf.Clamp01(p.age / birthDuration);
                Vector3 targetSurfacePos = p.initialDirection * sphereRadius;
                
                // 출생 구간에서는 표면으로 부드럽게 보간
                if (birthProgress < 1f)
                {
                    t.position = Vector3.Lerp(Vector3.zero, targetSurfacePos, birthProgress);
                }
                else
                {
                    // -------------------------------------------------
                    // [2. 노이즈 필드 기반 해류 흐름 (표면 구속)]
                    // -------------------------------------------------
                    Vector3 pos = t.position;
                    Vector3 normal = pos.normalized; // 현재 위치의 구 표면 법선

                    // 3D 공간에서의 일관된 노이즈 벡터 생성 (의사 3D Perlin)
                    // 각 축을 순환 참조하여 소용돌이(curl) 성질의 흐름 생성
                    float nx = Mathf.PerlinNoise(pos.y * noiseFrequency + currentTime, pos.z * noiseFrequency + currentTime * 0.3f) * 2f - 1f;
                    float ny = Mathf.PerlinNoise(pos.z * noiseFrequency + currentTime * 0.2f, pos.x * noiseFrequency + currentTime) * 2f - 1f;
                    float nz = Mathf.PerlinNoise(pos.x * noiseFrequency + currentTime * 0.4f, pos.y * noiseFrequency + currentTime * 0.1f) * 2f - 1f;

                    Vector3 noiseVector = new Vector3(nx, ny, nz) * noiseStrength;

                    // 노이즈 벡터의 방사형 성분을 제거하여 구 표면 접선 벡터만 추출
                    // tangent = noiseVector - (noiseVector dot normal) * normal
                    Vector3 tangent = noiseVector - Vector3.Dot(noiseVector, normal) * normal;

                    // 접선 방향으로 이동 적용
                    Vector3 nextPos = pos + tangent * flowSpeed * dt;

                    // 이동 후 다시 구 표면으로 정합 (반지름 고정)
                    nextPos = nextPos.normalized * sphereRadius;
                    t.position = nextPos;
                }

                // -------------------------------------------------
                // [3. 지속적 회전 적용]
                // -------------------------------------------------
                if (enableContinuousRotation)
                {
                    t.Rotate(
                        p.angularVelocity.x * dt,
                        p.angularVelocity.y * dt,
                        p.angularVelocity.z * dt,
                        Space.Self
                    );
                }

                // -------------------------------------------------
                // [4. 수명 종료 처리]
                // -------------------------------------------------
                if (p.remainingLife <= 0f)
                {
                    p.gameObject.SetActive(false);
                    p.isActive = false;
                }

                pool[i] = p;
            }
        }
    }

    // =========================================================
    // [Unity LifeCycle: OnDestroy]
    // =========================================================
    void OnDestroy()
    {
        foreach (var pool in prefabPools.Values)
        {
            foreach (var p in pool)
            {
                if (p.gameObject != null)
                    Destroy(p.gameObject);
            }
            pool.Clear();
        }
        prefabPools.Clear();
        validPrefabs.Clear();
    }
}