🫧Art_003 Perlin Noise Surface

📄Art_003_Perlin_Noise_Surface.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class PerlinNoiseSurface : MonoBehaviour
{
    [Header("그리드 구조 (변경 시 오브젝트 재생성)")]
    public int   gridSize = 20;
    public float spacing  = 1.2f;

    [Header("노이즈 설정")]
    public float noiseScale  = 0.15f;
    public float heightScale = 3f;
    public float noiseSpeed  = 0.5f;

    [Header("크기 설정")]
    public float sphereSize = 0.5f;

    [Header("색상 설정")]
    public Gradient gradient;

    [Header("재질 설정")]
    public Material baseMaterial;

    // ---------------------------------------------------
    // 구조 파라미터 캐시
    // ---------------------------------------------------
    private int   _cachedGridSize;
    private float _cachedSpacing;

    // ---------------------------------------------------
    // 구체 데이터
    // ---------------------------------------------------
    struct SphereData
    {
        public Transform tr;
        public Material  mat;
    }

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

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

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

    void OnEnable()
    {
        if (gradient == null || gradient.colorKeys.Length == 0)
            gradient = CreateDefaultGradient();

        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        if (gradient == null || gradient.colorKeys.Length == 0)
            gradient = CreateDefaultGradient();

        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()
    {
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
        ApplyAnimation(Time.time * noiseSpeed);
    }

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

    bool StructureParamsChanged() =>
        gridSize != _cachedGridSize || spacing != _cachedSpacing;

    void CacheStructureParams()
    {
        _cachedGridSize = gridSize;
        _cachedSpacing  = spacing;
    }

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

    void Generate()
    {
        Clear();

        float offset = (gridSize - 1) * spacing * 0.5f;

        for (int x = 0; x < gridSize; x++)
        for (int z = 0; z < gridSize; z++)
        {
            Vector3 pos = new Vector3(x * spacing - offset, 0f, z * spacing - offset);
            SpawnSphere(pos);
        }

        ApplyAnimation(0f);
    }

    void SpawnSphere(Vector3 pos)
    {
        if (baseMaterial == null)
        {
            Debug.LogWarning("[PerlinNoiseSurface] baseMaterial이 비어 있습니다. Inspector에서 URP/Lit 머티리얼을 할당해주세요.");
            return;
        }

        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        go.transform.SetParent(transform);
        go.transform.localPosition = pos;
        go.transform.localScale    = Vector3.one * sphereSize;

        Material mat = Instantiate(baseMaterial);
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

        go.GetComponent<Renderer>().material = mat;
        _spheres.Add(new SphereData { tr = go.transform, mat = mat });
    }

    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;

            Vector3 p = s.tr.localPosition;

            float n = Mathf.PerlinNoise(
                p.x * noiseScale + t,
                p.z * noiseScale + t * 0.8f
            );

            p.y = n * heightScale;
            s.tr.localPosition = p;
            s.tr.localScale    = Vector3.one * (sphereSize * (0.6f + n * 0.8f));

            Color albedo   = gradient.Evaluate(n);
            Color emission = albedo * (n * 0.6f);

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

    // ---------------------------------------------------
    // 유틸리티
    // ---------------------------------------------------

    Gradient CreateDefaultGradient()
    {
        Gradient g = new Gradient();
        g.SetKeys(
            new GradientColorKey[] {
                new GradientColorKey(Color.blue,   0.0f),
                new GradientColorKey(Color.cyan,   0.4f),
                new GradientColorKey(Color.green,  0.7f),
                new GradientColorKey(Color.yellow, 1.0f)
            },
            new GradientAlphaKey[] {
                new GradientAlphaKey(1f, 0f),
                new GradientAlphaKey(1f, 1f)
            }
        );
        return g;
    }
}

주석

using UnityEngine;
using System.Collections.Generic;

// UNITY_EDITOR: 에디터 전용 기능(EditorApplication 등)을 사용하기 위한 조건부 네임스페이스
#if UNITY_EDITOR
using UnityEditor;
#endif

// [ExecuteAlways]: 플레이 모드뿐 아니라 에디터 씬 뷰에서도 Update/OnEnable 등이 실행되도록 허용
[ExecuteAlways]
public class PerlinNoiseSurface : MonoBehaviour
{
    // -------------------------------------------------------
    // Inspector 노출 파라미터
    // -------------------------------------------------------

    [Header("그리드 구조 (변경 시 오브젝트 재생성)")]
    // gridSize: 가로·세로 방향에 배치할 구체의 수. 전체 구체 수 = gridSize * gridSize
    public int   gridSize = 20;
    // spacing: 이웃한 구체 사이의 간격(월드 유닛). 값이 클수록 구체가 넓게 퍼짐
    public float spacing  = 1.2f;

    [Header("노이즈 설정")]
    // noiseScale: PerlinNoise에 넘기는 좌표 배율. 작을수록 넓고 완만한 파형, 클수록 좁고 빠른 파형
    public float noiseScale  = 0.15f;
    // heightScale: 노이즈 값(0~1)에 곱해 Y축 변위로 변환하는 스케일. 높을수록 파고가 큼
    public float heightScale = 3f;
    // noiseSpeed: 시간축 오프셋 속도. Update에서 Time.time에 곱해 노이즈가 흐르는 속도를 결정
    public float noiseSpeed  = 0.5f;

    [Header("크기 설정")]
    // sphereSize: 각 구체의 기본 localScale 값. 애니메이션 중 맥동의 기준 크기로도 사용됨
    public float sphereSize = 0.5f;

    [Header("색상 설정")]
    // gradient: 노이즈 값(0~1)을 색상으로 매핑하는 그라디언트.
    //           Evaluate(n)으로 낮은 지점~높은 지점의 색을 연속적으로 보간함
    public Gradient gradient;

    [Header("재질 설정")]
    // baseMaterial: 구체 생성 시 Instantiate의 원본이 되는 URP Lit 머티리얼.
    //              Inspector에서 반드시 URP/Lit 기반 머티리얼을 직접 할당해야 함
    public Material baseMaterial;

    // -------------------------------------------------------
    // 구조 파라미터 캐시 — OnValidate 비교용
    // -------------------------------------------------------

    // _cachedGridSize / _cachedSpacing: 마지막으로 Generate()가 실행됐을 때의
    // gridSize·spacing 값을 저장. OnValidate에서 현재 값과 비교해
    // 실제로 구조가 바뀌었는지 판단하는 기준으로 사용됨
    private int   _cachedGridSize;
    private float _cachedSpacing;

    // -------------------------------------------------------
    // 구체 데이터 구조체
    // -------------------------------------------------------

    // SphereData: 개별 구체의 Transform과 인스턴스 Material을 묶는 경량 구조체.
    //             클래스 대신 struct를 사용해 힙 할당 없이 List에 값 복사로 저장됨
    struct SphereData
    {
        // tr: 구체 GameObject의 Transform. 위치(Y)와 크기(localScale)를 매 프레임 갱신할 때 사용
        public Transform tr;
        // mat: baseMaterial을 Instantiate한 개별 인스턴스. 구체마다 독립적인 색상 적용을 위해 복제함
        public Material  mat;
    }

    // _spheres: 생성된 모든 구체의 SphereData를 담는 리스트.
    //           ApplyAnimation()이 이 리스트를 순회하며 매 프레임 전체 구체를 갱신함
    List<SphereData> _spheres = new List<SphereData>();

    // -------------------------------------------------------
    // 에디터 전용 상태 플래그
    // -------------------------------------------------------

#if UNITY_EDITOR
    // _generateQueued: Generate()의 중복 예약을 막는 플래그.
    //                  OnValidate는 파라미터 변경마다 여러 번 호출될 수 있으므로
    //                  delayCall이 이미 등록돼 있으면 재등록하지 않도록 차단함
    bool _generateQueued = false;
#endif

    // -------------------------------------------------------
    // Unity 이벤트 메서드
    // -------------------------------------------------------

    // OnEnable: 컴포넌트가 활성화될 때(씬 로드, 컴포넌트 활성화, 에디터 재컴파일 후 등) 호출.
    //           그라디언트 초기화 → 구체 전체 생성 → 구조 파라미터 캐시 순으로 초기 상태를 구성함
    void OnEnable()
    {
        // 그라디언트가 비어 있으면 기본값으로 초기화
        if (gradient == null || gradient.colorKeys.Length == 0)
            gradient = CreateDefaultGradient();

        Generate();
        CacheStructureParams();
    }

    // OnValidate: Inspector에서 어떤 public 필드든 값이 바뀔 때마다 에디터에서 자동 호출.
    //             구조 파라미터(gridSize, spacing)가 바뀌면 구체를 재생성하고,
    //             그 외 파라미터(노이즈·색상·크기)만 바뀌면 재생성 없이 즉시 미리보기만 갱신함
    void OnValidate()
    {
#if UNITY_EDITOR
        if (gradient == null || gradient.colorKeys.Length == 0)
            gradient = CreateDefaultGradient();

        if (StructureParamsChanged())
        {
            // 구조가 바뀌었으면 캐시를 먼저 갱신하고 재생성 예약
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 노이즈·색상·크기 파라미터만 변경된 경우 → t=0 기준으로 즉시 씬 뷰 미리보기 갱신
            ApplyAnimation(0f);
        }
#endif
    }

#if UNITY_EDITOR
    // QueueGenerate: Generate()를 EditorApplication.delayCall에 등록해 다음 에디터 프레임에 실행되게 예약.
    //               OnValidate 도중에는 씬 그래프 수정이 제한되기 때문에,
    //               직접 호출 대신 delayCall로 한 프레임 뒤에 안전하게 실행함
    void QueueGenerate()
    {
        if (_generateQueued) return; // 이미 예약돼 있으면 중복 등록 방지

        _generateQueued = true;
        EditorApplication.delayCall += () =>
        {
            _generateQueued = false;
            if (this == null) return; // 컴포넌트가 삭제된 경우 조기 탈출
            Generate();
        };
    }
#endif

    // Update: 매 프레임 호출. 플레이 모드에서만 시간 기반 애니메이션을 구동함.
    //         에디터 씬 뷰에서는 정지 상태를 유지하기 위해 isPlaying 조건으로 차단
    void Update()
    {
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
        // Time.time * noiseSpeed: 경과 시간에 속도를 곱해 노이즈 오프셋을 선형으로 증가시킴
        ApplyAnimation(Time.time * noiseSpeed);
    }

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

    // StructureParamsChanged: 현재 Inspector 값과 캐시된 값을 비교해
    //                         구체를 재생성해야 하는 변경인지 판단함.
    //                         true를 반환하면 OnValidate가 QueueGenerate()를 호출함
    bool StructureParamsChanged() =>
        gridSize != _cachedGridSize || spacing != _cachedSpacing;

    // CacheStructureParams: 현재 gridSize·spacing을 캐시에 저장.
    //                       Generate() 직전 또는 OnEnable에서 호출해 기준값을 최신 상태로 유지함
    void CacheStructureParams()
    {
        _cachedGridSize = gridSize;
        _cachedSpacing  = spacing;
    }

    // -------------------------------------------------------
    // 구체 생성
    // -------------------------------------------------------

    // Generate: 기존 구체를 모두 삭제하고 gridSize×gridSize 개의 구체를 새로 배치함.
    //           그리드를 로컬 원점 기준으로 중앙 정렬한 뒤 각 셀 위치에 SpawnSphere를 호출함
    void Generate()
    {
        Clear();

        // offset: 그리드 전체 폭의 절반. 각 구체 위치에서 빼면 X·Z 축이 원점 대칭으로 정렬됨
        // 예) gridSize=20, spacing=1.2 → offset=11.4 → X 범위: -11.4 ~ +11.4
        float offset = (gridSize - 1) * spacing * 0.5f;

        for (int x = 0; x < gridSize; x++)
        for (int z = 0; z < gridSize; z++)
        {
            Vector3 pos = new Vector3(x * spacing - offset, 0f, z * spacing - offset);
            SpawnSphere(pos);
        }

        // 생성 직후 t=0 기준으로 노이즈 적용 → 에디터에서도 초기 형태를 즉시 확인 가능
        ApplyAnimation(0f);
    }

    // SpawnSphere: 주어진 로컬 위치에 구체 하나를 생성하고 _spheres 리스트에 등록함.
    //              baseMaterial을 Instantiate해 구체별 독립 머티리얼을 만들고,
    //              _EMISSION 키워드를 활성화해 실시간 에미션 색상 적용을 준비함
    void SpawnSphere(Vector3 pos)
    {
        if (baseMaterial == null)
        {
            Debug.LogWarning("[PerlinNoiseSurface] baseMaterial이 비어 있습니다. Inspector에서 URP/Lit 머티리얼을 할당해주세요.");
            return;
        }

        // CreatePrimitive: 메시·콜라이더가 내장된 기본 구체 GameObject를 생성함
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        go.transform.SetParent(transform);        // 이 컴포넌트의 GameObject를 부모로 설정해 계층 정리
        go.transform.localPosition = pos;
        go.transform.localScale    = Vector3.one * sphereSize;

        // Instantiate(baseMaterial): 원본 머티리얼을 복제해 구체마다 고유한 인스턴스를 만듦.
        //                            복제하지 않으면 모든 구체가 같은 머티리얼을 공유해 색상을 개별 제어할 수 없음
        Material mat = Instantiate(baseMaterial);
        // _EMISSION 키워드: URP Lit 셰이더에서 에미션 계산을 활성화하는 키워드.
        //                   이 키워드 없이 _EmissionColor를 설정해도 발광 효과가 적용되지 않음
        mat.EnableKeyword("_EMISSION");
        // RealtimeEmissive: 에미션 색상이 실시간으로 GI에 기여하도록 플래그를 설정함
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

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

        // SphereData 구조체로 묶어 리스트에 추가 → ApplyAnimation이 이 데이터를 참조함
        _spheres.Add(new SphereData { tr = go.transform, mat = mat });
    }

    // Clear: _spheres 리스트를 비우고 자식 GameObject를 전부 즉시 파괴함.
    //        DestroyImmediate: 에디터 모드에서는 Destroy가 동작하지 않으므로 즉시 삭제가 필요함
    void Clear()
    {
        _spheres.Clear();
        while (transform.childCount > 0)
            DestroyImmediate(transform.GetChild(0).gameObject);
    }

    // -------------------------------------------------------
    // 애니메이션 (노이즈 기반 위치·크기·색상 갱신)
    // -------------------------------------------------------

    // ApplyAnimation: 파라미터 t(시간 오프셋)를 받아 전체 구체의 Y 위치·크기·색상을 갱신함.
    //                 플레이 모드에서는 Update가 Time.time 기반 t를 전달하고,
    //                 에디터 미리보기 시에는 t=0으로 호출해 정적 스냅샷을 표시함
    void ApplyAnimation(float t)
    {
        for (int i = 0; i < _spheres.Count; i++)
        {
            SphereData s = _spheres[i];
            if (s.tr == null || s.mat == null) continue; // 외부에서 삭제된 경우 건너뜀

            Vector3 p = s.tr.localPosition;

            // PerlinNoise(x, y): 두 축 입력으로 0~1 사이의 연속적인 노이즈 값을 반환함.
            // p.x·p.z에 noiseScale을 곱해 공간 주파수를 조절하고,
            // t와 t*0.8f로 X·Z 축 오프셋에 서로 다른 속도를 주어 대각선이 아닌 자연스러운 2D 흐름을 만듦
            float n = Mathf.PerlinNoise(
                p.x * noiseScale + t,
                p.z * noiseScale + t * 0.8f
            );

            // Y 위치: 노이즈 값에 heightScale을 곱해 파도처럼 위아래로 변위시킴
            p.y = n * heightScale;
            s.tr.localPosition = p;

            // 크기 맥동: 노이즈가 낮을 때 0.6×, 높을 때 1.4× 크기가 되도록 선형 보간.
            //            구체가 높이 솟을수록 커지는 시각적 강조 효과를 만듦
            s.tr.localScale = Vector3.one * (sphereSize * (0.6f + n * 0.8f));

            // gradient.Evaluate(n): 노이즈 값을 그라디언트의 t 위치로 사용해 색상을 샘플링함
            Color albedo   = gradient.Evaluate(n);
            // emission: albedo에 노이즈 강도를 곱해 높은 지점일수록 밝게 발광하도록 스케일링함
            Color emission = albedo * (n * 0.6f);

            // URP Lit 셰이더의 프로퍼티 이름으로 색상을 직접 지정
            // _BaseColor: 표면의 알베도(기본 반사색)
            // _EmissionColor: 발광 색상. EnableKeyword("_EMISSION")이 선행돼야 실제로 적용됨
            s.mat.SetColor("_BaseColor",     albedo);
            s.mat.SetColor("_EmissionColor", emission);
        }
    }

    // -------------------------------------------------------
    // 유틸리티
    // -------------------------------------------------------

    // CreateDefaultGradient: gradient 필드가 비어 있을 때 사용할 기본 색상 배열을 생성함.
    //                         낮은 노이즈값(0) → 파랑, 높은 노이즈값(1) → 노랑 순으로
    //                         수심·고도감을 시각적으로 암시하는 팔레트를 제공함
    Gradient CreateDefaultGradient()
    {
        Gradient g = new Gradient();
        g.SetKeys(
            new GradientColorKey[] {
                new GradientColorKey(Color.blue,   0.0f),
                new GradientColorKey(Color.cyan,   0.4f),
                new GradientColorKey(Color.green,  0.7f),
                new GradientColorKey(Color.yellow, 1.0f)
            },
            // AlphaKey: 전 구간 alpha=1 (완전 불투명) 고정
            new GradientAlphaKey[] {
                new GradientAlphaKey(1f, 0f),
                new GradientAlphaKey(1f, 1f)
            }
        );
        return g;
    }
}
---