🫧Art_026 Mesh Particle System [게임오브젝트]

1. 개요

각 파티클을 독립적인 GameObject로 생성하고 스크립트로 위치/색상/수명을 관리합니다.

• 5개의 프리팹 슬롯에 메시 채우고, 채워진 슬롯 개수(n)에 따라 1/n 균등 확률로 생성.
• 각 파티클에 독립적인 컴포넌트나 콜라이더 부착 가능.
• 파티클 수가 많아지면(1000개 이상) 성능 저하 심함.
• Draw Call 이 많이 발생하여 렌더링 오버헤드 증가.
• 멀티 프리팹 풀링 시스템으로 성능 최적화.

1. Inspector 설정 방법

1. 빈 GameObject 생성 후 스크립트 첨부
2. Particle Settings 섹션의 Particle Prefabs 배열 크기 확인 (기본 5).
3. 원하는 모델링 메시가 적용된 프리팹을 슬롯 1개 이상 드래그&드롭으로 부착.
4. Max Particles 설정 시, 할당된 프리팹 개수(n)로 균등 분할됨. (예: MaxParticles=100, 프리팹 2개 -> 각 50개 풀 할당)

2. 확률 계산 원리 (1/n)

GameObject selectedPrefab = validPrefabs[Random.Range(0, validPrefabs.Count)];

• Random.Range(0, n) 은 0 부터 n-1 까지의 정수를 균등한 확률로 반환.
• 할당된 프리팹이 1개라면 100%, 2개라면 각 50%, 5개라면 각 20% 의 빈도로 선택됨.
• 빈 배열 슬롯(null) 은 validPrefabs 생성 시 자동으로 제외되므로 확률 계산에 영향을 주지 않음.

3. 풀링 시스템 (Pooling System) 동작 방식

• 성능 최적화를 위해 프리팹 타입별 독립 풀을 사용.
• SpawnParticle() 호출 시 선택된 프리팹에 해당하는 풀에서만 비활성화 객체를 재사용.
• 모든 풀이 활성 상태일 경우 경고 메시지와 함께 새 인스턴스를 생성하므로, Max Particles 값을 실제 필요 개수보다 여유 있게 설정하는 것을 권장.

4. Note

• 프리팹에 Mesh Renderer 또는 Skinned Mesh Renderer 가 올바르게 할당되어 있는지 확인.
• 회전 기능 (enableContinuousRotation) 이 활성화된 경우, 프리팹의 로컬 축이 비대칭이면 회전 방향이 제각각으로 보여 더 자연스러운 효과가 나옴.
• 런타임 중 Inspector 에서 프리팹 할당/해제를 반복할 경우, Start() 에서만 풀이 초기화되므로 Scene 을 재실행하거나 InitializePools() 를 직접 호출해야 변경사항이 반영됨.

2. 스크립트

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

public class MeshParticleSystem : MonoBehaviour
{
    // =========================================================
    // [Inspector 노출 변수: 파티클 기본 설정]
    // =========================================================
    [Header("Particle Settings")]
    [Tooltip("최대 5개의 프리팹을 할당할 수 있습니다. 최소 1개는 필수입니다.")]
    public GameObject[] particlePrefabs = new GameObject[5]; // 5개 슬롯 배열
    public int maxParticles = 100;        // 전체 시스템에서 관리할 파티클 총 개수
    public float spawnRate = 10f;         // 초당 생성 개수
    public Vector3 spawnAreaSize = new Vector3(5, 5, 5); // 생성 영역 크기
    
    // =========================================================
    // [Inspector 노출 변수: 이동 및 회전 설정]
    // =========================================================
    [Header("Motion Settings")]
    public float minSpeed = 1f;           // 최소 이동 속도
    public float maxSpeed = 5f;           // 최대 이동 속도
    public float lifetime = 3f;           // 파티클 수명
    
    [Header("Rotation Settings")]
    public bool enableRandomStartRotation = true;  // 시작 시 랜덤 회전 적용 여부
    public bool enableContinuousRotation = true;   // 지속적 회전 적용 여부
    public Vector3 minAngularVelocity = new Vector3(-30f, -30f, -30f); // 최소 각속도 (도/초)
    public Vector3 maxAngularVelocity = new Vector3(30f, 30f, 30f);    // 최대 각속도 (도/초)
    
    // =========================================================
    // [Private 멤버 변수: 풀링 및 유효성 검사]
    // =========================================================
    private List<GameObject> validPrefabs = new List<GameObject>();                // null이 아닌 프리팹만 필터링한 리스트
    private Dictionary<GameObject, List<ParticleData>> prefabPools = new Dictionary<GameObject, List<ParticleData>>(); // 프리팹별 파티클 풀
    private float spawnTimer = 0f;
    private int totalAllocatedParticles = 0; // 실제로 할당된 파티클 총합
    
    // =========================================================
    // [파티클 데이터 구조체]
    // =========================================================
    private struct ParticleData
    {
        public GameObject gameObject;         // 파티클 GameObject
        public GameObject assignedPrefab;     // 이 파티클이 속한 프리팹 타입
        public Vector3 velocity;              // 이동 속도 벡터
        public Vector3 angularVelocity;       // 각 축별 회전 속도 (도/초)
        public float remainingLife;           // 남은 수명
        public bool isActive;                 // 활성화 상태
    }
    
    // =========================================================
    // [Unity LifeCycle: OnValidate (Inspector 변경 시 자동 호출)]
    // =========================================================
    void OnValidate()
    {
        // Inspector 에서 배열 변경 시 유효 프리팹 목록 갱신
        validPrefabs.Clear();
        foreach (var p in particlePrefabs)
        {
            if (p != null && !validPrefabs.Contains(p))
                validPrefabs.Add(p);
        }
        
        // 최소 1개 할당 경고
        if (validPrefabs.Count == 0 && Application.isPlaying)
            Debug.LogWarning("[ManualParticleSystem] 최소 1개의 프리팹을 할당해야 시스템이 동작합니다.");
        
        // 속도/회전 범위 보정
        if (minSpeed > maxSpeed) maxSpeed = minSpeed;
        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;
    }
    
    // =========================================================
    // [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("[ManualParticleSystem] 동작하려면 최소 1개의 프리팹이 할당되어야 합니다. 스크립트를 비활성화합니다.");
            enabled = false;
            return;
        }
        
        // 프리팹별 파티클 풀 초기화 및 개수 분배
        InitializePools();
    }
    
    // =========================================================
    // [Private Method: 프리팹별 파티클 풀 생성 및 균등 분배]
    // =========================================================
    void InitializePools()
    {
        int validCount = validPrefabs.Count;
        int baseCount = maxParticles / validCount;
        int remainder = maxParticles % validCount;
        totalAllocatedParticles = 0;
        
        foreach (var prefab in validPrefabs)
        {
            List<ParticleData> pool = new List<ParticleData>();
            // 나머지 파티클은 순서대로 추가하여 총합이 maxParticles 가 되도록 균등 분배
            int countForThisPrefab = baseCount + (remainder > 0 ? 1 : 0);
            remainder--;
            
            for (int i = 0; i < countForThisPrefab; i++)
            {
                GameObject go = Instantiate(prefab, transform);
                go.SetActive(false);
                
                pool.Add(new ParticleData
                {
                    gameObject = go,
                    assignedPrefab = prefab,
                    velocity = Vector3.zero,
                    angularVelocity = Vector3.zero,
                    remainingLife = 0f,
                    isActive = false
                });
                totalAllocatedParticles++;
            }
            prefabPools[prefab] = pool;
        }
        
        Debug.Log($"[ManualParticleSystem] {validCount}개 프리팹에 총 {totalAllocatedParticles}개 파티클 풀 할당 완료.");
    }
    
    // =========================================================
    // [Unity LifeCycle: Update]
    // =========================================================
    void Update()
    {
        // 파티클 생성 타이머 처리
        spawnTimer += Time.deltaTime;
        if (spawnTimer >= 1f / spawnRate)
        {
            spawnTimer = 0f;
            SpawnParticle();
        }
        
        // 모든 파티클 업데이트 (이동 + 회전 + 수명)
        UpdateParticles();
    }
    
    // =========================================================
    // [Private Method: 파티클 생성 (1/n 확률 균등 분배)]
    // =========================================================
    void SpawnParticle()
    {
        // 1/n 균등 확률로 유효 프리팹 중 하나 선택
        GameObject selectedPrefab = validPrefabs[Random.Range(0, validPrefabs.Count)];
        List<ParticleData> targetPool = prefabPools[selectedPrefab];
        
        // 해당 프리팹 풀에서 비활성화된 파티클 탐색
        ParticleData? foundParticle = null;
        for (int i = 0; i < targetPool.Count; i++)
        {
            if (!targetPool[i].isActive)
            {
                foundParticle = targetPool[i];
                break;
            }
        }
        
        // 풀이 가득 찬 경우 새 인스턴스 생성 (성능 경고 발생)
        if (foundParticle == null)
        {
            Debug.LogWarning($"[ManualParticleSystem] {selectedPrefab.name} 풀이 가득 찼습니다. 새 인스턴스를 생성합니다. (maxParticles 증가 권장)");
            GameObject go = Instantiate(selectedPrefab, transform);
            go.SetActive(false);
            ParticleData newP = new ParticleData
            {
                gameObject = go,
                assignedPrefab = selectedPrefab,
                velocity = Vector3.zero,
                angularVelocity = Vector3.zero,
                remainingLife = 0f,
                isActive = false
            };
            targetPool.Add(newP);
            foundParticle = newP;
            totalAllocatedParticles++;
        }
        
        // -------------------------------------------------
        // [파티클 활성화 및 데이터 설정]
        // -------------------------------------------------
        ParticleData p = foundParticle.Value;
        
        // 랜덤 위치 생성
        Vector3 spawnPos = transform.position + 
            new Vector3(
                Random.Range(-spawnAreaSize.x * 0.5f, spawnAreaSize.x * 0.5f),
                Random.Range(-spawnAreaSize.y * 0.5f, spawnAreaSize.y * 0.5f),
                Random.Range(-spawnAreaSize.z * 0.5f, spawnAreaSize.z * 0.5f)
            );
        
        // 랜덤 이동 속도
        Vector3 randomVelocity = Random.onUnitSphere * Random.Range(minSpeed, maxSpeed);
        
        // 랜덤 각속도
        Vector3 randomAngularVelocity = new Vector3(
            Random.Range(minAngularVelocity.x, maxAngularVelocity.x),
            Random.Range(minAngularVelocity.y, maxAngularVelocity.y),
            Random.Range(minAngularVelocity.z, maxAngularVelocity.z)
        );
        
        // 위치/회전 적용
        p.gameObject.transform.position = spawnPos;
        if (enableRandomStartRotation)
            p.gameObject.transform.rotation = Random.rotationUniform;
        else
            p.gameObject.transform.rotation = Quaternion.identity;
        
        // 데이터 업데이트
        p.velocity = randomVelocity;
        p.angularVelocity = randomAngularVelocity;
        p.remainingLife = lifetime;
        p.isActive = true;
        p.gameObject.SetActive(true);
        
        // 변경 사항 풀에 반영 (값 타입 struct 이므로 명시적 재할당 필요)
        int index = targetPool.IndexOf(foundParticle.Value);
        targetPool[index] = p;
    }
    
    // =========================================================
    // [Private Method: 파티클 업데이트]
    // =========================================================
    void UpdateParticles()
    {
        // 모든 풀을 순회하며 업데이트
        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;
                
                // 위치 업데이트
                t.position += p.velocity * Time.deltaTime;
                
                // 회전 업데이트
                if (enableContinuousRotation)
                {
                    t.Rotate(
                        p.angularVelocity.x * Time.deltaTime,
                        p.angularVelocity.y * Time.deltaTime,
                        p.angularVelocity.z * Time.deltaTime,
                        Space.Self
                    );
                }
                
                // 수명 감소
                p.remainingLife -= Time.deltaTime;
                
                // 수명 종료 시 비활성화
                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();
    }
}