using UnityEngine;

/// <summary>
/// 기본적인 GPU Instancing 활성화 예제.
/// 동일 메시와 머티리얼을 사용하는 오브젝트를 씬에 다수 배치하면
/// Unity가 자동으로 인스턴싱을 적용한다.
/// </summary>
public class SimpleGPUInstancingExample : MonoBehaviour
{
    [SerializeField] private GameObject prefab;       // 동일 메시+머티리얼의 프리팹
    [SerializeField] private int count = 100;         // 생성 개수
    [SerializeField] private float spacing = 2.0f;    // 간격

    void Start()
    {
        // 머티리얼에서 "Enable GPU Instancing" 체크 필요
        // 동일 메시+머티리얼 프리팹을 그리드로 배치
        for (int i = 0; i < count; i++)
        {
            Vector3 position = new Vector3(
                (i % 10) * spacing,
                0,
                (i / 10) * spacing
            );
            Instantiate(prefab, position, Quaternion.identity);
        }
    }
}

using UnityEngine;

/// <summary>
/// Graphics.RenderMeshInstanced를 활용한 대량 오브젝트 렌더링.
/// GameObject를 생성하지 않으므로 CPU 오버헤드가 매우 낮다.
/// </summary>
public class AdvancedGPUInstancing : MonoBehaviour
{
    [Header("렌더링 설정")]
    [SerializeField] private Mesh mesh;                // 렌더링할 메시
    [SerializeField] private Material material;        // GPU Instancing 지원 머티리얼
    [SerializeField] private int instanceCount = 1000; // 인스턴스 수

    [Header("배치 설정")]
    [SerializeField] private float areaSize = 50f;     // 배치 영역 크기
    [SerializeField] private float minScale = 0.5f;    // 최소 스케일
    [SerializeField] private float maxScale = 2.0f;    // 최대 스케일

    // 인스턴스 변환 행렬 배열 (최대 1023개까지 한 번에 렌더링 가능)
    private Matrix4x4[] _matrices;
    private RenderParams _renderParams;

    void Start()
    {
        InitializeInstances();
    }

    /// <summary>
    /// 인스턴스 데이터를 초기화한다.
    /// 랜덤 위치와 스케일로 변환 행렬을 생성한다.
    /// </summary>
    private void InitializeInstances()
    {
        _matrices = new Matrix4x4[instanceCount];

        for (int i = 0; i < instanceCount; i++)
        {
            // 랜덤 위치 생성
            Vector3 position = new Vector3(
                Random.Range(-areaSize, areaSize),
                0f,
                Random.Range(-areaSize, areaSize)
            );

            // 랜덤 회전 생성
            Quaternion rotation = Quaternion.Euler(0, Random.Range(0f, 360f), 0);

            // 랜덤 균일 스케일 생성
            float scale = Random.Range(minScale, maxScale);
            Vector3 scaleVec = Vector3.one * scale;

            _matrices[i] = Matrix4x4.TRS(position, rotation, scaleVec);
        }

        // RenderParams 설정 (매 프레임 재생성을 피하기 위해 캐싱)
        _renderParams = new RenderParams(material)
        {
            receiveShadows = true,
            shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On
        };
    }

    void Update()
    {
        // 인스턴스 수가 1023개를 초과하면 여러 번 나눠서 호출
        int batchSize = 1023; // API 제한: 한 번에 최대 1023개
        for (int i = 0; i < instanceCount; i += batchSize)
        {
            int count = Mathf.Min(batchSize, instanceCount - i);
            Graphics.RenderMeshInstanced(
                _renderParams,
                mesh,
                0,            // submeshIndex
                _matrices,
                count,        // 이번 배치에서 렌더링할 인스턴스 수
                i             // 시작 인덱스
            );
        }
    }
}

using UnityEngine;

/// <summary>
/// MaterialPropertyBlock을 사용하여 인스턴스별 색상을 설정하는 예제.
/// 각 오브젝트가 고유한 색상을 가지면서도 GPU Instancing의 혜택을 받는다.
/// </summary>
public class PerInstanceColor : MonoBehaviour
{
    [SerializeField] private GameObject prefab;
    [SerializeField] private int count = 200;

    void Start()
    {
        MaterialPropertyBlock mpb = new MaterialPropertyBlock();

        for (int i = 0; i < count; i++)
        {
            Vector3 pos = new Vector3(
                (i % 20) * 1.5f,
                0,
                (i / 20) * 1.5f
            );

            GameObject obj = Instantiate(prefab, pos, Quaternion.identity);
            Renderer rend = obj.GetComponent<Renderer>();

            // 인스턴스별 고유 색상 설정
            // 주의: 인스턴스 속성만 MaterialPropertyBlock에 넣어야 한다.
            //       비인스턴스 속성을 넣으면 인스턴싱이 깨진다.
            mpb.SetColor("_Color", Random.ColorHSV());
            rend.SetPropertyBlock(mpb);
        }
    }
}

using UnityEngine;
using UnityEngine.Rendering;

/// <summary>
/// SRP Batcher를 런타임에서 활성화/비활성화하는 기본 예제.
/// URP/HDRP에서는 기본적으로 활성화되어 있다.
/// </summary>
public class SimpleSRPBatcherToggle : MonoBehaviour
{
    void Start()
    {
        // SRP Batcher 활성화
        GraphicsSettings.useScriptableRenderPipelineBatching = true;
        Debug.Log("SRP Batcher 활성화됨");
    }

    /// <summary>
    /// 디버깅 목적으로 SRP Batcher를 토글하는 메서드.
    /// 프레임 디버거에서 배칭 효과를 비교할 때 유용하다.
    /// </summary>
    public void ToggleSRPBatcher()
    {
        bool current = GraphicsSettings.useScriptableRenderPipelineBatching;
        GraphicsSettings.useScriptableRenderPipelineBatching = !current;
        Debug.Log($"SRP Batcher: {!current}");
    }
}

using UnityEngine;
using UnityEngine.Rendering;

/// <summary>
/// SRP Batcher 호환성 검증 및 머티리얼 관리 실용 예제.
/// 런타임에서 SRP Batcher 상태를 모니터링하고,
/// 머티리얼 속성 변경 시 배칭이 유지되는 올바른 방법을 보여준다.
/// </summary>
public class SRPBatcherManager : MonoBehaviour
{
    [SerializeField] private Material[] materials;
    [SerializeField] private Renderer[] renderers;

    void Start()
    {
        // SRP Batcher 활성화 확인
        if (!GraphicsSettings.useScriptableRenderPipelineBatching)
        {
            GraphicsSettings.useScriptableRenderPipelineBatching = true;
            Debug.Log("SRP Batcher를 활성화했습니다.");
        }

        // 머티리얼의 SRP Batcher 호환성 확인
        // Frame Debugger (Window > Analysis > Frame Debugger)에서
        // "SRP Batch" 항목으로 배칭 상태를 확인할 수 있다.
    }

    /// <summary>
    /// SRP Batcher가 깨지지 않도록 머티리얼 속성을 올바르게 변경하는 방법.
    /// MaterialPropertyBlock은 사용하지 않는다.
    /// 대신 Material 인스턴스의 속성을 직접 수정한다.
    /// </summary>
    public void ChangeMaterialColorSafely(Renderer renderer, Color newColor)
    {
        // [올바른 방법] Material 인스턴스 직접 수정
        // SRP Batcher는 동일 셰이더 Variant 간에 작동하므로
        // 머티리얼 속성이 달라도 배칭이 유지된다.
        renderer.material.SetColor("_BaseColor", newColor);

        // [잘못된 방법] - MaterialPropertyBlock은 SRP Batcher를 깨뜨린다
        // var mpb = new MaterialPropertyBlock();
        // mpb.SetColor("_BaseColor", newColor);
        // renderer.SetPropertyBlock(mpb);  // SRP Batch 해제됨!
    }

    /// <summary>
    /// 대량의 오브젝트에 다양한 색상을 적용하면서
    /// SRP Batcher 배칭을 유지하는 패턴.
    /// </summary>
    public void ApplyVariousColors(Renderer[] targetRenderers)
    {
        foreach (var rend in targetRenderers)
        {
            // renderer.material 접근 시 자동으로 머티리얼 인스턴스가 생성된다.
            // 동일 셰이더를 사용하는 한 SRP Batcher 배칭이 유지된다.
            rend.material.SetColor("_BaseColor", Random.ColorHSV());
        }
    }
}

using UnityEngine;

/// <summary>
/// 에디터에서 Static Batching을 설정하는 가장 기본적인 방법.
/// 오브젝트를 "Batching Static"으로 마크하면 빌드 시 자동으로 결합된다.
/// </summary>
public class SimpleStaticBatchingExample : MonoBehaviour
{
    [SerializeField] private GameObject[] staticObjects;

    void Awake()
    {
        // 에디터에서의 설정 방법:
        // 1. Player Settings > Other Settings > "Static Batching" 체크 확인
        // 2. 움직이지 않는 오브젝트 선택 > Inspector > Static 체크박스 > "Batching Static" 활성화
        // 3. 빌드 시 Unity가 자동으로 메시를 결합함

        // 코드에서 오브젝트를 정적으로 마크하는 방법
        foreach (var obj in staticObjects)
        {
            // GameObjectUtility.SetStaticEditorFlags는 에디터 전용이므로
            // 런타임에서는 StaticBatchingUtility를 사용한다
            obj.isStatic = true;
        }
    }
}

using UnityEngine;

/// <summary>
/// 런타임에서 프로시저럴하게 생성한 오브젝트에 Static Batching을 적용하는 예제.
/// StaticBatchingUtility.Combine()을 사용하여 메시를 결합한다.
/// </summary>
public class RuntimeStaticBatching : MonoBehaviour
{
    [Header("프로시저럴 생성 설정")]
    [SerializeField] private Mesh[] meshVariants;      // 다양한 메시 종류
    [SerializeField] private Material sharedMaterial;   // 공유 머티리얼
    [SerializeField] private int objectCount = 500;     // 생성할 오브젝트 수
    [SerializeField] private float spawnRadius = 100f;  // 생성 반경

    [Header("배칭 설정")]
    [SerializeField] private Transform batchRoot;       // 배칭 루트 트랜스폼

    void Start()
    {
        GenerateAndBatch();
    }

    /// <summary>
    /// 오브젝트를 프로시저럴하게 생성한 뒤 Static Batching으로 결합한다.
    /// </summary>
    private void GenerateAndBatch()
    {
        // 배칭 루트가 없으면 생성
        if (batchRoot == null)
        {
            GameObject root = new GameObject("StaticBatchRoot");
            batchRoot = root.transform;
        }

        // 오브젝트 생성
        for (int i = 0; i < objectCount; i++)
        {
            GameObject obj = new GameObject($"StaticObj_{i}");
            obj.transform.SetParent(batchRoot);

            // 랜덤 위치 배치
            Vector3 randomPos = Random.insideUnitSphere * spawnRadius;
            randomPos.y = 0; // 바닥에 배치
            obj.transform.localPosition = randomPos;
            obj.transform.localRotation = Quaternion.Euler(0, Random.Range(0f, 360f), 0);

            // 메시 필터 및 렌더러 추가
            MeshFilter mf = obj.AddComponent<MeshFilter>();
            MeshRenderer mr = obj.AddComponent<MeshRenderer>();

            // 랜덤 메시 선택 (같은 머티리얼을 사용해야 배칭 효과 극대화)
            mf.sharedMesh = meshVariants[Random.Range(0, meshVariants.Length)];
            mr.sharedMaterial = sharedMaterial;
        }

        // 핵심: StaticBatchingUtility.Combine으로 메시 결합
        // batchRoot의 모든 자식 오브젝트가 결합 대상이 된다
        StaticBatchingUtility.Combine(batchRoot.gameObject);

        Debug.Log($"Static Batching 완료: {objectCount}개 오브젝트 결합됨");

        // 메모리 최적화: 결합 후 원본 메시의 CPU 복사본 해제
        // (결합된 메시 데이터가 이미 GPU에 업로드되었으므로)
        // 주의: 이후 메시 데이터에 CPU에서 접근할 수 없게 된다
        OptimizeMemory();
    }

    /// <summary>
    /// 결합 완료 후 불필요한 CPU측 메시 데이터를 해제하여 메모리를 절약한다.
    /// </summary>
    private void OptimizeMemory()
    {
        MeshFilter[] filters = batchRoot.GetComponentsInChildren<MeshFilter>();
        foreach (var filter in filters)
        {
            if (filter.sharedMesh != null && filter.sharedMesh.isReadable)
            {
                // GPU에 업로드 후 CPU 복사본 삭제
                filter.sharedMesh.UploadMeshData(true);
            }
        }
    }

    /// <summary>
    /// 특정 오브젝트 배열만 선택적으로 배칭하는 오버로드 활용 예제.
    /// </summary>
    public void BatchSpecificObjects(GameObject[] objectsToBatch)
    {
        // 특정 오브젝트 배열을 루트 아래에 배칭
        StaticBatchingUtility.Combine(objectsToBatch, batchRoot.gameObject);
        Debug.Log($"선택적 Static Batching 완료: {objectsToBatch.Length}개 오브젝트");
    }
}