🫧Art_002 Random Sphere

📒 RandomSphereGenerator.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class RandomSphereGenerator : MonoBehaviour
{
    [Header("구체 구조 (변경 시 오브젝트 재생성)")]
    public int sphereCount = 500;
    public float spawnRange = 5f;
    public int randomSeed = 42;         // 동일한 시드 = 동일한 배치

    [Header("부유 애니메이션 설정")]
    public float floatSpeed = 0.8f;     // 부유 주기
    public float floatAmplitude = 0.4f; // 부유 높이
    public float phaseSpread = 3.0f;    // 구체 간 위상 차이

    [Header("크기 설정")]
    public float scaleMin = 0.15f;
    public float scaleMax = 0.6f;

    [Header("색상")]
    [Range(0f, 1f)] public float hueBase = 0.6f;
    [Range(0f, 1f)] public float hueRange = 0.4f;
    [Range(0f, 1f)] public float saturation = 0.75f;
    [Range(0f, 1f)] public float brightness = 1.0f;

    // ---------------------------------------------------
    // 구조 파라미터 캐시 (OnValidate 비교용)
    // ---------------------------------------------------
    private int   _cachedSphereCount;
    private float _cachedSpawnRange;
    private int   _cachedRandomSeed;

    // ---------------------------------------------------
    // 구체 데이터
    // ---------------------------------------------------
    struct SphereData
    {
        public Transform tr;
        public Material  mat;
        public Vector3   basePos;    // 생성 시 기준 위치
        public float     phase;      // 부유 위상 오프셋
        public float     normalized; // 0~1 (색상·크기용)
    }

    List<SphereData> _spheres = new List<SphereData>();

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

    // ---------------------------------------------------
    // Unity 이벤트
    // ---------------------------------------------------

    void OnEnable()
    {
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 색상·애니메이션 파라미터만 바뀐 경우 → 즉시 미리보기 갱신
            ApplyAnimation(0f);
        }
#endif
    }

#if UNITY_EDITOR
    void QueueGenerate()
    {
        if (_generateQueued) return;

        _generateQueued = true;
        EditorApplication.delayCall += () =>
        {
            _generateQueued = false;
            if (this == null) return;
            Generate();
        };
    }
#endif

    void Update()
    {
        // 에디터 Scene 뷰에서는 애니메이션 정지
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
        ApplyAnimation(Time.time);
    }

    // ---------------------------------------------------
    // 구조 파라미터 변경 감지
    // ---------------------------------------------------

    bool StructureParamsChanged()
    {
        return sphereCount  != _cachedSphereCount
            || spawnRange   != _cachedSpawnRange
            || randomSeed   != _cachedRandomSeed;
    }

    void CacheStructureParams()
    {
        _cachedSphereCount = sphereCount;
        _cachedSpawnRange  = spawnRange;
        _cachedRandomSeed  = randomSeed;
    }

    // ---------------------------------------------------
    // 생성
    // ---------------------------------------------------

    void Generate()
    {
        Clear();

        Random.InitState(randomSeed); // 시드 고정 → 재생성해도 동일한 배치

        for (int i = 0; i < sphereCount; i++)
        {
            float t = (sphereCount > 1) ? (float)i / (sphereCount - 1) : 0f;

            Vector3 pos = new Vector3(
                Random.Range(-spawnRange, spawnRange),
                Random.Range(-spawnRange, spawnRange),
                Random.Range(-spawnRange, spawnRange)
            );

            float phase = Random.value * phaseSpread; // 구체마다 다른 위상

            SpawnSphere(pos, phase, t);
        }

        ApplyAnimation(0f);
    }

    void SpawnSphere(Vector3 pos, float phase, float normalized)
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        go.transform.SetParent(transform);
        go.transform.localPosition = pos;

        Material mat = new Material(Shader.Find("Universal Render Pipeline/Lit"));
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

        go.GetComponent<Renderer>().material = mat;

        _spheres.Add(new SphereData
        {
            tr         = go.transform,
            mat        = mat,
            basePos    = pos,
            phase      = phase,
            normalized = normalized
        });
    }

    void Clear()
    {
        _spheres.Clear();
        while (transform.childCount > 0)
            DestroyImmediate(transform.GetChild(0).gameObject);
    }

    // ---------------------------------------------------
    // 애니메이션
    // ---------------------------------------------------

    void ApplyAnimation(float t)
    {
        for (int i = 0; i < _spheres.Count; i++)
        {
            SphereData s = _spheres[i];
            if (s.tr == null || s.mat == null) continue;

            // 각 구체가 자신의 위상으로 Y축 부유
            float bob = Mathf.Sin(t * floatSpeed + s.phase) * floatAmplitude;

            s.tr.localPosition = new Vector3(
                s.basePos.x,
                s.basePos.y + bob,
                s.basePos.z
            );

            // 부유 상태에 따라 크기 맥동 (위로 올라갈수록 커짐)
            float bobNormalized = (bob / floatAmplitude + 1f) * 0.5f; // 0~1
            float scale = Mathf.Lerp(scaleMin, scaleMax, bobNormalized);
            s.tr.localScale = Vector3.one * scale;

            // 색상
            float hue     = (hueBase + s.normalized * hueRange) % 1f;
            Color albedo   = Color.HSVToRGB(hue, saturation, brightness);
            Color emission = Color.HSVToRGB(hue, 1f, bobNormalized) * 0.5f;

            s.mat.SetColor("_BaseColor",     albedo);
            s.mat.SetColor("_EmissionColor", emission);
        }
    }
}