// CustomRenderPipelineAsset.cs
// 커스텀 파이프라인의 설정 데이터를 저장하는 ScriptableObject
using UnityEngine;
using UnityEngine.Rendering;

// Unity 에디터의 메뉴에서 에셋 생성 가능
[CreateAssetMenu(menuName = "Rendering/Custom Render Pipeline")]
public class CustomRenderPipelineAsset : RenderPipelineAsset
{
    // 파이프라인 설정값 (Inspector에서 편집 가능)
    public Color clearColor = Color.black;

    // 파이프라인 인스턴스 생성 - Unity가 렌더링 시 호출
    protected override RenderPipeline CreatePipeline()
    {
        return new CustomRenderPipeline(this);
    }
}

// CustomRenderPipeline.cs
// 실제 렌더링 로직을 담당하는 파이프라인 인스턴스
using UnityEngine;
using UnityEngine.Rendering;
using System.Collections.Generic;

public class CustomRenderPipeline : RenderPipeline
{
    private CustomRenderPipelineAsset pipelineAsset;

    public CustomRenderPipeline(CustomRenderPipelineAsset asset)
    {
        pipelineAsset = asset;
    }

    // 매 프레임 호출 - 모든 활성 카메라에 대해 렌더링 수행
    protected override void Render(
        ScriptableRenderContext context, List<Camera> cameras)
    {
        // 각 카메라에 대해 렌더링 실행
        foreach (Camera camera in cameras)
        {
            RenderCamera(context, camera);
        }
    }

    private void RenderCamera(ScriptableRenderContext context, Camera camera)
    {
        // 카메라 속성 설정 (VP 행렬 등)
        context.SetupCameraProperties(camera);

        // CommandBuffer를 사용하여 렌더 타겟 클리어
        CommandBuffer cmd = new CommandBuffer { name = "Clear" };
        cmd.ClearRenderTarget(
            clearDepth: true,
            clearColor: true,
            backgroundColor: pipelineAsset.clearColor
        );

        // 명령 실행 및 버퍼 해제
        context.ExecuteCommandBuffer(cmd);
        cmd.Release();

        // 스카이박스 그리기
        context.DrawSkybox(camera);

        // 모든 스케줄된 명령을 GPU에 제출
        context.Submit();
    }
}

// CameraRenderer.cs
// 개별 카메라의 렌더링을 처리하는 클래스
using UnityEngine;
using UnityEngine.Rendering;

public class CameraRenderer
{
    // 프로파일러에 표시될 이름
    private const string BufferName = "Render Camera";

    // 재사용 가능한 CommandBuffer
    private CommandBuffer buffer = new CommandBuffer { name = BufferName };

    private ScriptableRenderContext context;
    private Camera camera;
    private CullingResults cullingResults;

    // Unlit 셰이더 태그 ID
    private static ShaderTagId unlitShaderTagId = new ShaderTagId("SRPDefaultUnlit");
    // Lit 셰이더 태그 ID
    private static ShaderTagId litShaderTagId = new ShaderTagId("UniversalForward");

    /// <summary>
    /// 카메라 렌더링 진입점
    /// </summary>
    public void Render(ScriptableRenderContext context, Camera camera)
    {
        this.context = context;
        this.camera = camera;

        // 1단계: 컬링 - 카메라에 보이지 않는 오브젝트 제외
        if (!Cull())
            return;

        // 2단계: 초기 설정
        Setup();

        // 3단계: 가시 지오메트리 그리기
        DrawVisibleGeometry();

        // 4단계: GPU에 명령 제출
        Submit();
    }

    /// <summary>
    /// 컬링 수행 - 카메라 절두체(Frustum) 밖의 오브젝트 제외
    /// </summary>
    private bool Cull()
    {
        if (camera.TryGetCullingParameters(out ScriptableCullingParameters parameters))
        {
            cullingResults = context.Cull(ref parameters);
            return true;
        }
        return false;
    }

    /// <summary>
    /// 렌더 타겟 초기화 및 카메라 속성 설정
    /// </summary>
    private void Setup()
    {
        // 카메라의 뷰/프로젝션 행렬 설정
        context.SetupCameraProperties(camera);

        // 렌더 타겟 클리어 (깊이 + 색상)
        CameraClearFlags flags = camera.clearFlags;
        buffer.ClearRenderTarget(
            flags <= CameraClearFlags.Depth,
            flags <= CameraClearFlags.Color,
            flags == CameraClearFlags.Color ? camera.backgroundColor.linear : Color.clear
        );

        // 프로파일러 샘플 시작
        buffer.BeginSample(BufferName);
        ExecuteBuffer();
    }

    /// <summary>
    /// 가시 지오메트리 드로잉 - 불투명 > 스카이박스 > 투명 순서
    /// </summary>
    private void DrawVisibleGeometry()
    {
        // --- 불투명 오브젝트 (앞에서 뒤로 정렬) ---
        var sortingSettings = new SortingSettings(camera)
        {
            criteria = SortingCriteria.CommonOpaque
        };
        var drawingSettings = new DrawingSettings(unlitShaderTagId, sortingSettings);
        drawingSettings.SetShaderPassName(1, litShaderTagId);
        var filteringSettings = new FilteringSettings(RenderQueueRange.opaque);

        context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings);

        // --- 스카이박스 ---
        context.DrawSkybox(camera);

        // --- 투명 오브젝트 (뒤에서 앞으로 정렬) ---
        sortingSettings.criteria = SortingCriteria.CommonTransparent;
        drawingSettings.sortingSettings = sortingSettings;
        filteringSettings.renderQueueRange = RenderQueueRange.transparent;

        context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings);
    }

    /// <summary>
    /// 스케줄된 모든 명령을 GPU에 제출
    /// </summary>
    private void Submit()
    {
        buffer.EndSample(BufferName);
        ExecuteBuffer();
        context.Submit();
    }

    /// <summary>
    /// CommandBuffer 실행 후 초기화
    /// </summary>
    private void ExecuteBuffer()
    {
        context.ExecuteCommandBuffer(buffer);
        buffer.Clear();
    }
}

// CustomRenderPipelineAdvanced.cs
// CameraRenderer를 사용하는 파이프라인 인스턴스
using UnityEngine;
using UnityEngine.Rendering;
using System.Collections.Generic;

public class CustomRenderPipelineAdvanced : RenderPipeline
{
    // CameraRenderer 인스턴스 재사용
    private CameraRenderer renderer = new CameraRenderer();

    protected override void Render(
        ScriptableRenderContext context, List<Camera> cameras)
    {
        // 모든 활성 카메라에 대해 렌더링
        for (int i = 0; i < cameras.Count; i++)
        {
            renderer.Render(context, cameras[i]);
        }
    }
}

// BlurRendererFeature.cs
// URP에 블러 포스트 프로세싱 효과를 추가하는 Renderer Feature
using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class BlurRendererFeature : ScriptableRendererFeature
{
    // Inspector에서 설정할 블러 파라미터
    [SerializeField] private BlurSettings settings;
    [SerializeField] private Shader blurShader;

    private Material blurMaterial;
    private BlurRenderPass blurPass;

    /// <summary>
    /// Renderer Feature 초기화 - 패스 생성
    /// </summary>
    public override void Create()
    {
        if (blurShader == null) return;

        blurMaterial = new Material(blurShader);
        blurPass = new BlurRenderPass(blurMaterial, settings);

        // 스카이박스 이후에 블러 적용
        blurPass.renderPassEvent = RenderPassEvent.AfterRenderingSkybox;
    }

    /// <summary>
    /// 매 프레임 호출 - 렌더 패스를 큐에 등록
    /// </summary>
    public override void AddRenderPasses(
        ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        // 게임 카메라에서만 적용 (Scene뷰 등 제외)
        if (renderingData.cameraData.cameraType == CameraType.Game)
        {
            renderer.EnqueuePass(blurPass);
        }
    }

    /// <summary>
    /// 리소스 해제
    /// </summary>
    protected override void Dispose(bool disposing)
    {
        blurPass?.Dispose();
        if (blurMaterial != null)
            CoreUtils.Destroy(blurMaterial);
    }
}

/// <summary>
/// 블러 설정 데이터
/// </summary>
[Serializable]
public class BlurSettings
{
    [Range(0f, 0.4f)] public float horizontalBlur = 0.1f;
    [Range(0f, 0.4f)] public float verticalBlur = 0.1f;
}

// BlurRenderPass.cs
// 실제 블러 렌더링을 수행하는 패스
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class BlurRenderPass : ScriptableRenderPass
{
    // 셰이더 프로퍼티 ID 캐싱 (문자열 검색 비용 제거)
    private static readonly int HorizontalBlurId =
        Shader.PropertyToID("_HorizontalBlur");
    private static readonly int VerticalBlurId =
        Shader.PropertyToID("_VerticalBlur");

    private BlurSettings settings;
    private Material material;
    private RenderTextureDescriptor descriptor;
    private RTHandle blurTexture;

    public BlurRenderPass(Material material, BlurSettings settings)
    {
        this.material = material;
        this.settings = settings;
        descriptor = new RenderTextureDescriptor(
            Screen.width, Screen.height,
            RenderTextureFormat.Default, 0);
    }

    /// <summary>
    /// 렌더 텍스처 설정 - 카메라 해상도에 맞춤
    /// </summary>
    public override void Configure(
        CommandBuffer cmd, RenderTextureDescriptor cameraDescriptor)
    {
        descriptor.width = cameraDescriptor.width;
        descriptor.height = cameraDescriptor.height;
        RenderingUtils.ReAllocateIfNeeded(ref blurTexture, descriptor);
    }

    /// <summary>
    /// 매 프레임 실행 - 2패스 블러 적용
    /// </summary>
    public override void Execute(
        ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get("BlurPass");

        RTHandle cameraTarget =
            renderingData.cameraData.renderer.cameraColorTargetHandle;

        // 블러 강도 설정
        material.SetFloat(HorizontalBlurId, settings.horizontalBlur);
        material.SetFloat(VerticalBlurId, settings.verticalBlur);

        // 패스 0: 수평 블러 (카메라 -> 임시 텍스처)
        Blit(cmd, cameraTarget, blurTexture, material, 0);
        // 패스 1: 수직 블러 (임시 텍스처 -> 카메라)
        Blit(cmd, blurTexture, cameraTarget, material, 1);

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    /// <summary>
    /// 리소스 해제
    /// </summary>
    public void Dispose()
    {
        blurTexture?.Release();
    }
}

// HDRPVolumeSetup.cs
// HDRP Volume Profile을 코드로 설정하는 예제
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;

public class HDRPVolumeSetup : MonoBehaviour
{
    private Volume volume;
    private VolumeProfile profile;

    void Start()
    {
        // Volume 컴포넌트 추가
        volume = gameObject.AddComponent<Volume>();
        volume.isGlobal = true; // 전역 적용
        volume.priority = 1;

        // Volume Profile 생성
        profile = ScriptableObject.CreateInstance<VolumeProfile>();
        volume.profile = profile;

        // Bloom 효과 추가
        SetupBloom();

        // Tonemapping 설정
        SetupTonemapping();

        // Ambient Occlusion 설정
        SetupAmbientOcclusion();
    }

    private void SetupBloom()
    {
        var bloom = profile.Add<Bloom>();
        bloom.active = true;
        bloom.intensity.value = 0.3f;           // 블룸 강도
        bloom.intensity.overrideState = true;
        bloom.scatter.value = 0.7f;              // 블룸 확산 범위
        bloom.scatter.overrideState = true;
        bloom.threshold.value = 1.0f;            // HDR 임계값
        bloom.threshold.overrideState = true;
    }

    private void SetupTonemapping()
    {
        var tonemap = profile.Add<Tonemapping>();
        tonemap.active = true;
        tonemap.mode.value = TonemappingMode.ACES; // 영화 산업 표준 톤맵핑
        tonemap.mode.overrideState = true;
    }

    private void SetupAmbientOcclusion()
    {
        // HDRP의 Screen Space Ambient Occlusion
        var ssao = profile.Add<ScreenSpaceAmbientOcclusion>();
        ssao.active = true;
        ssao.intensity.value = 1.0f;
        ssao.intensity.overrideState = true;
        ssao.radius.value = 2.0f;
        ssao.radius.overrideState = true;
    }

    void OnDestroy()
    {
        // 런타임 생성 프로파일 정리
        if (profile != null)
            DestroyImmediate(profile);
    }
}

// GrayScale.cs
// HDRP 커스텀 포스트 프로세싱 - 그레이스케일 효과
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using System;

// Volume 메뉴에 등록 - Inspector에서 Add Override로 추가 가능
[Serializable, VolumeComponentMenu("Post-processing/Custom/GrayScale")]
public sealed class GrayScale
    : CustomPostProcessVolumeComponent, IPostProcessComponent
{
    // Volume에서 조절할 파라미터 (0~1 범위 제한)
    [Tooltip("그레이스케일 효과 강도를 조절합니다.")]
    public ClampedFloatParameter intensity =
        new ClampedFloatParameter(0f, 0f, 1f);

    private Material material;

    /// <summary>
    /// 이 효과가 활성 상태인지 판단
    /// intensity가 0이면 렌더링을 건너뛰어 성능 절약
    /// </summary>
    public bool IsActive() => material != null && intensity.value > 0f;

    /// <summary>
    /// 포스트 프로세싱 주입 시점 설정
    /// AfterPostProcess: Unity 내장 포스트 프로세싱 이후 적용
    /// </summary>
    public override CustomPostProcessInjectionPoint injectionPoint =>
        CustomPostProcessInjectionPoint.AfterPostProcess;

    /// <summary>
    /// 초기화 - 셰이더로부터 머티리얼 생성
    /// </summary>
    public override void Setup()
    {
        Shader shader = Shader.Find("Hidden/Shader/GrayScale");
        if (shader != null)
            material = new Material(shader);
    }

    /// <summary>
    /// 매 프레임 렌더링 실행
    /// </summary>
    public override void Render(
        CommandBuffer cmd, HDCamera camera,
        RTHandle source, RTHandle destination)
    {
        if (material == null) return;

        // 셰이더에 강도 파라미터 전달
        material.SetFloat("_Intensity", intensity.value);

        // source -> destination으로 풀스크린 블릿
        cmd.Blit(source, destination, material, 0);
    }

    /// <summary>
    /// 머티리얼 정리
    /// </summary>
    public override void Cleanup()
    {
        CoreUtils.Destroy(material);
    }
}