🫧Art_006 Sine Grid [GPU Instancing]

📄Art_006_Sine_Grid_GPU.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class Art_SineGrid_GPU : MonoBehaviour
{
    [Header("그리드 구조 (변경 시 재계산)")]
    public int   gridSize  = 150;
    public float spacing   = 0.3f;
    public float cubeSize  = 0.25f;
    public int   colorSeed = 0;

    [Header("파동 설정 (실시간 반영)")]
    public float waveHeight    = 0.4f;
    public float waveSpeed     = 1.5f;
    public float waveFrequency = 0.8f;

    [Header("색상 설정 (실시간 반영)")]
    [ColorUsage(false)] public Color baseColor = Color.white;
    public float emissionIntensity = 0.4f;

    [Header("PBR 재질 설정 (실시간 반영)")]
    [Range(0f, 1f)] public float metallic  = 0.0f;
    [Range(0f, 1f)] public float smoothness = 0.5f;
    [Range(0f, 1f)] public float occlusionStrength = 1.0f;

    [Header("재질 설정")]
    public Mesh     cubeMesh;
    public Material instanceMaterial;

    // ---------------------------------------------------
    // 구조 파라미터 캐시 (에디터용)
    // ---------------------------------------------------
    private int   _cachedGridSize;
    private float _cachedSpacing;
    private float _cachedCubeSize;
    private int   _cachedColorSeed;

    // ---------------------------------------------------
    // 인스턴싱 데이터
    // ---------------------------------------------------
    struct InstanceData
    {
        public Vector3 basePos;
    }

    List<InstanceData> _instances = new List<InstanceData>();

    Matrix4x4[] _matrices;
    
    const int BATCH_SIZE = 1023;
    bool      _generated = false;

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

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

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

    void OnValidate()
    {
#if UNITY_EDITOR
        EnsureResources();

        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
#endif
    }

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

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

    void Update()
    {
        if (!_generated) return;

#if UNITY_EDITOR
        if (!Application.isPlaying)
        {
            Animate(0f);
            RenderInstances();
            return;
        }
#endif
        Animate(Time.time * waveSpeed);
        RenderInstances();
    }

    // ---------------------------------------------------
    // 구조 파라미터 변경 감지 (에디터용)
    // ---------------------------------------------------

    bool StructureParamsChanged()
    {
        return gridSize  != _cachedGridSize
            || spacing   != _cachedSpacing
            || cubeSize  != _cachedCubeSize
            || colorSeed != _cachedColorSeed;
    }

    void CacheStructureParams()
    {
        _cachedGridSize  = gridSize;
        _cachedSpacing   = spacing;
        _cachedCubeSize  = cubeSize;
        _cachedColorSeed = colorSeed;
    }

    // ---------------------------------------------------
    // 리소스 초기화
    // ---------------------------------------------------

    void EnsureResources()
    {
        // ▶️ cubeMesh 자동 생성
        if (cubeMesh == null)
        {
            GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
            cubeMesh = temp.GetComponent<MeshFilter>().sharedMesh;
#if UNITY_EDITOR
            DestroyImmediate(temp);
#else
            Destroy(temp);
#endif
        }

        // ▶️ instanceMaterial 자동 생성 (URP 전용)
        if (instanceMaterial == null)
        {
            Shader urpShader = Shader.Find("Universal Render Pipeline/Lit");
            if (urpShader == null)
            {
                Debug.LogWarning("[Art_SineGrid_GPU] URP 셰이더를 찾을 수 없습니다. Inspector 에서 instanceMaterial 을 직접 할당해주세요.");
                return;
            }

            instanceMaterial = new Material(urpShader);
            instanceMaterial.enableInstancing = true;
            instanceMaterial.EnableKeyword("_EMISSION");
            instanceMaterial.globalIlluminationFlags = 
                MaterialGlobalIlluminationFlags.RealtimeEmissive;

            Debug.Log("[Art_SineGrid_GPU] 인스턴스 머티리얼 자동 생성 (URP/Lit)");
        }
    }

    // ---------------------------------------------------
    // 그리드 생성
    // ---------------------------------------------------

    void Generate()
    {
        _instances.Clear();
        _generated = false;

        Random.InitState(colorSeed);
        float offset = (gridSize - 1) * spacing * 0.5f;

        for (int x = 0; x < gridSize; x++)
        {
            for (int z = 0; z < gridSize; z++)
            {
                _instances.Add(new InstanceData
                {
                    basePos = new Vector3(x * spacing - offset, 0f, z * spacing - offset)
                });
            }
        }

        _matrices = new Matrix4x4[_instances.Count];
        _generated = true;

        Animate(0f);
    }

    // ---------------------------------------------------
    // 애니메이션 (위치만 업데이트)
    // ---------------------------------------------------

    void Animate(float t)
    {
        for (int i = 0; i < _instances.Count; i++)
        {
            InstanceData inst = _instances[i];

            // 파동 계산 - 위치만 변경
            float wave = Mathf.Sin((inst.basePos.x + inst.basePos.z) * waveFrequency + t) * waveHeight;

            // 위치: 월드 변환 적용
            Vector3 pos = transform.TransformPoint(
                new Vector3(inst.basePos.x, wave, inst.basePos.z)
            );
            _matrices[i] = Matrix4x4.TRS(pos, transform.rotation, Vector3.one * cubeSize);
        }
    }

    // ---------------------------------------------------
    // GPU 인스턴싱 드로우 (PBR 재질 적용)
    // ---------------------------------------------------

    void RenderInstances()
    {
        if (cubeMesh == null || instanceMaterial == null || !_generated) return;

        int total = _instances.Count;
        int index = 0;

        while (total > 0)
        {
            int batch = Mathf.Min(BATCH_SIZE, total);

            // 배치 단위 행렬 배열
            Matrix4x4[] batchMatrices = new Matrix4x4[batch];
            System.Array.Copy(_matrices, index, batchMatrices, 0, batch);

            // MaterialPropertyBlock - PBR 재질 설정
            MaterialPropertyBlock block = new MaterialPropertyBlock();
            
            // 1. Base Color (단일 색상 - 모든 인스턴스 동일)
            block.SetColor("_BaseColor", baseColor);
            
            // 2. Emission Color
            Color emissionColor = baseColor * emissionIntensity;
            block.SetColor("_EmissionColor", emissionColor);
            
            // 3. Metallic (URP/Lit 표준 프로퍼티)
            block.SetFloat("_Metallic", metallic);
            
            // 4. Smoothness (URP/Lit 표준 프로퍼티)
            block.SetFloat("_Smoothness", smoothness);
            
            // 5. Occlusion Strength
            block.SetFloat("_OcclusionStrength", occlusionStrength);

            // GPU 인스턴싱 드로우
            Graphics.DrawMeshInstanced(
                cubeMesh,
                0,
                instanceMaterial,
                batchMatrices,
                batch,
                block
            );

            index += batch;
            total -= batch;
        }
    }
}