using System;
using UnityEngine;
using UnityEngine.Rendering.Universal;

namespace TechBlog.Rendering
{
    /// <summary>
    /// ForegroundTransparentFeature
    ///
    /// 반투명 오브젝트를 맨앞면에 그리는 ScriptableRendererFeature。
    /// 심도 프리패스를 쓰는 것으로, 반투명 오브젝트끼리의 심도를 정확하게 제어합니다.
    ///
    /// 구성：
    /// ① _depthPass : DepthOnly 패스로 심도 프리패스
    /// ② _colorPass : 컬러 드로잉 패스(SRPDefaultUnlit / UniversalForward)
    ///
    /// 전부 RenderPassEvent 의 순서로 실행됩니다.
    /// </summary>
    public class ForegroundTransparentFeature : ScriptableRendererFeature
    {
        [Serializable]
        public class Settings
        {
            [Tooltip("그리기 대상의 레이어 마스크")]
            public LayerMask layerMask = 0;

            [HideInInspector]
            public string[] depthTagNames = { "DepthOnly" };

            [HideInInspector]
            public string[] colorTagNames = { "UniversalForward", "SRPDefaultUnlit" };

            [HideInInspector]
            public string passTagPrefix = "ForegroundTransparent";
        }

        public Settings settings = new();

        // 각 패스
        private ForegroundTransparentPass _depthPass;
        private ForegroundTransparentPass _colorPass;

        public override void Create()
        {
            // ① DepthOnly 프리패스
            _depthPass = new ForegroundTransparentPass(
                $"{settings.passTagPrefix}_Depth",
                settings.depthTagNames,
                RenderPassEvent.BeforeRenderingTransparents,
                settings.layerMask,
                ForegroundTransparentPass.PassMode.DepthOnly
            );

            // ② 컬러 드로잉 패스(Unlit + Lit모두 지원)
            _colorPass = new ForegroundTransparentPass(
                $"{settings.passTagPrefix}_Color",
                settings.colorTagNames,
                RenderPassEvent.BeforeRenderingTransparents + 1,
                settings.layerMask,
                ForegroundTransparentPass.PassMode.Color
            );
        }

        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            // Preview카메라에서는 스킵
            if (renderingData.cameraData.cameraType == CameraType.Preview)
            {
                return;
            }

            // RenderPassEvent의 오름차순으로 자동 실행됩니다.
            renderer.EnqueuePass(_depthPass);
            renderer.EnqueuePass(_colorPass);
        }
    }
}

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RendererUtils;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering.Universal;

namespace TechBlog.Rendering
{
    /// <summary>
    /// 가장 앞쪽 반투명 오브젝트용 범용 렌더 패스
    /// 모드에 따라 심도만 쓰기, 또는 컬러 + 심도 쓰기로 전환 가능
    /// </summary>
    public class ForegroundTransparentPass : ScriptableRenderPass
    {
        /// <summary>
        /// 패스 모드
        /// </summary>
        public enum PassMode
        {
            DepthOnly,  // 심도만 쓰기
            Color,      // 컬러 + 심도 쓰기
        }

        private readonly string _profilerTag;
        private readonly ProfilingSampler _profilingSampler;
        private readonly LayerMask _layerMask;
        private readonly RenderStateBlock _renderStateBlock;
        private readonly List<ShaderTagId> _shaderTagIds = new();
        private readonly PassMode _mode;

        public ForegroundTransparentPass(
            string tag,
            string[] drawTagNames,
            RenderPassEvent passEvent,
            LayerMask layerMask,
            PassMode mode
        )
        {
            _profilerTag = tag;
            _profilingSampler = new ProfilingSampler(tag);
            renderPassEvent = passEvent;
            _layerMask = layerMask;
            _mode = mode;

            // 렌더 상태의 사용자 정의가 필요한 경우 여기서 설정
            _renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);

            if (drawTagNames != null)
            {
                foreach (var name in drawTagNames)
                {
                    if (!string.IsNullOrEmpty(name))
                    {
                        _shaderTagIds.Add(new ShaderTagId(name));
                    }
                }
            }
        }

        public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
        {
            var cameraData = frameData.Get<UniversalCameraData>();
            var renderingData = frameData.Get<UniversalRenderingData>();
            var resourceData = frameData.Get<UniversalResourceData>();

            // 반투명 오브젝트의 표준적인 순서
            var sorting = SortingCriteria.CommonTransparent;

            // Lit 쉐더에서 필요한, PerObject 정보를 유효화
            // (Unlit 의 경우는 불필요한 정보는 무시됩니다)
            var perObject = PerObjectData.Lightmaps
                            | PerObjectData.LightProbe
                            | PerObjectData.LightProbeProxyVolume
                            | PerObjectData.ReflectionProbes
                            | PerObjectData.ShadowMask
                            | PerObjectData.OcclusionProbe
                            | PerObjectData.OcclusionProbeProxyVolume
                            | PerObjectData.LightData
                            | PerObjectData.ReflectionProbeData;

            foreach (var shaderTag in _shaderTagIds)
            {
                using var builder = renderGraph.AddRasterRenderPass<PassData>(
                    $"{_profilerTag}_{shaderTag.name}", out var passData, _profilingSampler);

                // 모드에 따라 어태치먼트를 설정
                if (_mode == PassMode.Color)
                {
                    // 컬러 + 심도 쓰기
                    passData.Color = resourceData.activeColorTexture;
                    builder.SetRenderAttachment(passData.Color, 0);
                    builder.SetRenderAttachmentDepth(resourceData.activeDepthTexture);
                }
                else // DepthOnly
                {
                    // 컬러 어태치먼트를 읽기 전용으로 어태치
                    // (RenderGraph의 유효성 검사 요건을 충족하기 위해)
                    builder.SetRenderAttachment(resourceData.activeColorTexture, 0, AccessFlags.Read);
                    // 심도 어태치먼트에는 쓰기
                    builder.SetRenderAttachmentDepth(resourceData.activeDepthTexture, AccessFlags.Write);
                }

                var rendererListDesc = new RendererListDesc(shaderTag, renderingData.cullResults, cameraData.camera)
                {
                    sortingCriteria = sorting,
                    renderQueueRange = RenderQueueRange.all,
                    layerMask = _layerMask,
                    stateBlock = _renderStateBlock,
                    rendererConfiguration = perObject,
                };

                passData.RendererList = renderGraph.CreateRendererList(rendererListDesc);
                builder.UseRendererList(passData.RendererList);

                // 프로파일상에 가시화하기 위해, 컬링을 무효화
                builder.AllowPassCulling(false);

                builder.SetRenderFunc((PassData data, RasterGraphContext context) =>
                {
                    context.cmd.DrawRendererList(data.RendererList);
                });
            }
        }

        private class PassData
        {
            public TextureHandle Color;
            public RendererListHandle RendererList;
        }
    }
}

Shader "TechBlog/ForegroundTransparent"
{
    Properties
    {
        _BaseColor("Base Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
        Tags
        {
            "RenderType" = "Transparent"
            "Queue" = "Transparent"
        }

        Pass
        {
            Name "Unlit"
            Tags { "LightMode" = "SRPDefaultUnlit" }

            Blend SrcAlpha One
            ZWrite Off
            ZTest LEqual
            Cull Back

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
            };

            CBUFFER_START(UnityPerMaterial)
                half4 _BaseColor;
            CBUFFER_END

            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                return output;
            }

            half4 frag(Varyings input) : SV_Target
            {
                return _BaseColor;
            }
            ENDHLSL
        }

        Pass
        {
            Name "DepthPrepass"
            Tags { "LightMode" = "DepthOnly" }

            ZWrite On
            ColorMask 0
            ZTest LEqual
            Cull Back

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
            };

            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                return output;
            }

            half4 frag(Varyings input) : SV_Target
            {
                return half4(0, 0, 0, 0);
            }
            ENDHLSL
        }
    }

    FallBack "Hidden/Universal Render Pipeline/FallbackError"
}