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"
}