🫧Art_004 Radial Energy Field [Game Object]

GameObject에 붙여서 사용

주요 함수 및 기능 설명

1. MaterialPropertyBlock 의 역할

"메모리를 아끼면서 색상을 바꾸는 마법 상자"

• 기존 방식의 문제점 (renderer.material 직접 수정):

  • 유니티에서 renderer.material에 접근하여 색상을 바꾸면, 유니티는 자동으로 해당 머티리얼을 복제(Clone)하여 새로운 메모리 공간을 할당합니다.
  • 이 스크립트처럼 구체가 수백 개라면, 수백 개의 복제된 머티리얼이 생성되어 메모리 사용량이 급증하고, GPU가 이를 처리하기 위해 드로우콜(Draw Call)이 분리되어 성능이 급격히 저하됩니다 (배칭 Breaking).

• MaterialPropertyBlock의 해결책:

  • 머티리얼 자체를 복제하지 않고, "이 오브젝트만 색상을 이렇게 바꿔서 그려줘"라는 임시 데이터 블록을 렌더러에 전달합니다.
  • 머티리얼은 하나만 공유하므로 메모리가 낭비되지 않고, GPU 입장에서도 상태 변경이 최소화되어 성능이 훨씬 좋습니다.

• 코드에서의 적용:

// 1. 블록 데이터 생성 (한 번만 생성해두고 재사용)
_propBlock.SetColor("_BaseColor", albedo); 

// 2. 렌더러에 전달 (머티리얼 원본은 건드리지 않음)
s.renderer.SetPropertyBlock(_propBlock);

2. Material CreateURPMaterial()

"설정 귀찮을 때 쉐이더를 알아서 찾아주는 자동화 함수"

이 메서드는 스크립트가 실행될 때 인스펙터에 머티리얼이 없다면, URP 환경에 맞는 표준 머티리얼을 코드로 직접 생성하는 역할을 합니다.

• 상세 기능 분석:

1. Shader.Find("Universal Render Pipeline/Lit"): 유니티 URP 프로젝트의 표준 쉐이더를 찾습니다. 이는 Unity 6.0 URP 환경에서 가장 호환성이 좋은 쉐이더입니다.
2. new Material(shader): 찾은 쉐이더로 새로운 머티리얼 인스턴스를 만듭니다.
3. mat.EnableKeyword("_EMISSION"): 머티리얼의 발광(Emission) 기능을 켭니다. 이 키워드가 켜져야 _EmissionColor 프로퍼티가 작동합니다.
4. 반환: 생성된 머티리얼을 baseMaterial 변수에 할당해 줍니다.

• 사용 이유:
  사용자가 매번 프로젝트 창에서 머티리얼을 만들고 쉐이더를 설정하고, Emission을 켜는 번거로움을 없애기 위함입니다. 프리팹(Prefab)만 배치해도 알아서 제대로 된 머티리얼이 적용됩니다.

3. MaterialGlobalIlluminationFlags

"빛을 내뿜는 녀석이 주변도 밝히게 만드는 설정"

이 속성은 머티리얼이 글로벌 일루미네이션(Global Illumination, GI) 시스템과 어떻게 상호작용할지를 결정합니다.

• 설정값 RealtimeEmissive의 의미:

  • 이 머티리얼은 실시간(Realtime)으로 빛을 내뿜는다는 뜻입니다.
  • 단순히 오브젝트 자체가 빛나는 것에 그치지 않고, 주변 벽이나 바닥, 다른 오브젝트들에게도 빛을 비추는 영향을 줍니다. (예: 에너지 필드 아래 바닥이 푸르게 물드는 효과)

• 코드에서의 역할:

mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

이 코드가 없다면 구체는 스스로 빛나 보일 뿐, 주변 환경에는 아무런 빛의 영향을 주지 않는 '자체 발광(Self-Illuminated)' 상태로만 남게 됩니다. 이 코드를 통해 에너지 필드가 실제 광원처럼 행동하도록 설정합니다.

• 성능 관련 참고할 사항:
  • 실시간 GI는 계산 비용이 비쌉니다. 만약 수백 개의 구체가 모두 주변에 빛을 비춘다면 성능에 부담이 될 수 있습니다.
  • 성능이 중요한 모바일이나 저사양 환경에서는 None으로 설정하여 주변 조명 영향을 끄거나, Light Probe를 활용하는 방식으로 최적화하기도 합니다. 하지만 PC/콘솔 급의 비주얼 퀄리티를 위해서는 RealtimeEmissive가 적절합니다.

코드

📄Art_004_Radial_Energy_Field.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class RadialEnergyField : MonoBehaviour
{
    [Header("그리드 구조 (변경 시 오브젝트 재생성)")]
    public int ringCount = 15;
    public int baseSegments = 6;
    public float ringSpacing = 1.2f;

    [Header("에너지 파동 설정")]
    public float waveHeight = 2.0f;
    public float waveSpeed = 1.4f;
    public float waveFrequency = 1.5f;

    [Header("회전 필드 설정")]
    public float swirlStrength = 0.4f;
    public float radialPulse = 0.6f;

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

    [Header("색상 설정 (직접 수정 가능)")]
    [Tooltip("파동의 최소 색상 (알파 포함)")]
    public Color colorMin = new Color(0.0f, 0.5f, 1.0f, 1.0f); 
    [Tooltip("파동의 최대 색상 (알파 포함)")]
    public Color colorMax = new Color(1.0f, 1.0f, 1.0f, 1.0f); 
    [Tooltip("발광 강도")]
    public float emissionIntensity = 1f;

    [Header("재질 설정 (URP)")]
    [Tooltip("비워두면 자동으로 URP Lit 머티리얼을 생성합니다.")]
    public Material baseMaterial;

    // 내부 캐싱 변수
    private int _cachedRingCount;
    private int _cachedBaseSegments;
    private float _cachedRingSpacing;

    struct SphereData
    {
        public Transform tr;
        public Renderer renderer;
        public float radius;
        public float angle;
        public Vector3 basePos;
    }

    List<SphereData> spheres = new List<SphereData>();
    MaterialPropertyBlock _propBlock;

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

    void OnEnable()
    {
        transform.position = Vector3.zero;
        transform.rotation = Quaternion.identity;

        if (baseMaterial == null)
            baseMaterial = CreateURPMaterial();

        _propBlock = new MaterialPropertyBlock();
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        if (baseMaterial == null)
            baseMaterial = CreateURPMaterial();

        if (StructureParamsChanged())
        {
            QueueGenerate();
            CacheStructureParams();
        }
        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 * waveSpeed);
    }

    bool StructureParamsChanged()
    {
        return ringCount != _cachedRingCount
            || baseSegments != _cachedBaseSegments
            || ringSpacing != _cachedRingSpacing;
    }

    void CacheStructureParams()
    {
        _cachedRingCount = ringCount;
        _cachedBaseSegments = baseSegments;
        _cachedRingSpacing = ringSpacing;
    }

    // ---------------------------------------------------
    // 생성 로직
    // ---------------------------------------------------

    void Generate()
    {
        Clear();
        SpawnSphere(Vector3.zero, 0, 0);

        for (int ring = 1; ring <= ringCount; ring++)
        {
            float radius = ring * ringSpacing;
            int segments = baseSegments * ring;

            for (int s = 0; s < segments; s++)
            {
                float angle = (float)s / segments * Mathf.PI * 2f;
                Vector3 pos = new Vector3(Mathf.Cos(angle) * radius, 0, Mathf.Sin(angle) * radius);
                SpawnSphere(pos, radius, angle);
            }
        }
        ApplyAnimation(0f);
    }

    void SpawnSphere(Vector3 pos, float radius, float angle)
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);

        // ---------------------------------------------------
        // 콜라이더 및 리지드바디 추가 로직
        // ---------------------------------------------------
        
        // 1. Collider: CreatePrimitive가 자동으로 생성하므로 삭제하지 않음.
        // 필요하다면 트리거 설정 (예: 플레이어가 통과할 때 이벤트용)
        // SphereCollider col = go.GetComponent<SphereCollider>();
        // col.isTrigger = true; 

        // 2. Rigidbody 추가
        Rigidbody rb = go.AddComponent<Rigidbody>();
        rb.isKinematic = true; // 스크립트가 위치를 제어하므로 물리적 힘은 받지 않도록 설정 (중요)
        rb.useGravity = false; // 중력 꺼두기

        go.transform.SetParent(transform);
        go.transform.localPosition = pos;
        go.transform.localScale = Vector3.one * scaleMin;

        Renderer renderer = go.GetComponent<Renderer>();
        renderer.sharedMaterial = baseMaterial;

        spheres.Add(new SphereData
        {
            tr = go.transform,
            renderer = renderer,
            radius = radius,
            angle = angle,
            basePos = pos
        });
    }

    // ---------------------------------------------------
    // 애니메이션 및 색상 적용
    // ---------------------------------------------------

    void ApplyAnimation(float t)
    {
        if (_propBlock == null) _propBlock = new MaterialPropertyBlock();

        for (int i = 0; i < spheres.Count; i++)
        {
            SphereData s = spheres[i];
            if (s.tr == null || s.renderer == null) continue;

            float wave = Mathf.Sin(s.radius * waveFrequency - t) * waveHeight;
            float normalized = (wave / waveHeight + 1f) * 0.5f;

            float swirl = Mathf.Sin(t + s.radius) * swirlStrength;
            float angle = s.angle + swirl;
            float r = s.radius + Mathf.Sin(t + s.radius) * radialPulse;

            Vector3 p = new Vector3(Mathf.Cos(angle) * r, wave, Mathf.Sin(angle) * r);

            s.tr.localPosition = p;

            float scale = Mathf.Lerp(scaleMin, scaleMax, normalized);
            s.tr.localScale = Vector3.one * scale;

            Color albedo = Color.Lerp(colorMin, colorMax, normalized);
            Color emission = albedo * emissionIntensity;

            _propBlock.SetColor("_BaseColor", albedo);
            _propBlock.SetColor("_EmissionColor", emission);
            s.renderer.SetPropertyBlock(_propBlock);
        }
    }

    Material CreateURPMaterial()
    {
        Shader shader = Shader.Find("Universal Render Pipeline/Lit");
        if (shader == null)
        {
            Debug.LogError("URP Lit Shader를 찾을 수 없습니다.");
            return new Material(Shader.Find("Standard"));
        }

        Material mat = new Material(shader);
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
        return mat;
    }

    void Clear()
    {
        foreach (Transform child in transform)
        {
            if (Application.isPlaying)
                Destroy(child.gameObject);
            else
                DestroyImmediate(child.gameObject);
        }
        spheres.Clear();
    }
}