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

namespace Example.Graphics
{
    public class CustomRenderPass : ScriptableRenderPass
    {
        private readonly string _profilerTag;
        private readonly ProfilingSampler _profilingSampler;

        private readonly Material _overrideMaterial;
        private readonly int _overrideMaterialPassIndex;
        private readonly LayerMask _layerMask;

        private readonly RenderStateBlock _renderStateBlock;
        private readonly List<ShaderTagId> _shaderTagIds = new();

        public CustomRenderPass(
                string tag,
                string shaderTagName,
                RenderPassEvent passEvent,
                LayerMask layerMask
        )
        {
            _profilerTag = tag;
            _profilingSampler = new ProfilingSampler(tag);
            renderPassEvent = passEvent;

            _layerMask = layerMask;
            _renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);

            if (!string.IsNullOrEmpty(shaderTagName))
            {
                _shaderTagIds.Add(new ShaderTagId(shaderTagName));
            }
        }

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

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

                passData.ColorTarget = resourceData.activeColorTexture;

                builder.SetRenderAttachment(passData.ColorTarget, 0);
                builder.SetRenderAttachmentDepth(resourceData.activeDepthTexture);

                var sorting = SortingCriteria.CommonOpaque;

                var rendererListDesc = new RendererListDesc(
                        shaderTag,
                        renderingData.cullResults,
                        cameraData.camera
                )
                {
                    sortingCriteria = sorting,
                    renderQueueRange = RenderQueueRange.opaque,
                    layerMask = _layerMask,
                    overrideMaterial = _overrideMaterial,
                    overrideMaterialPassIndex = _overrideMaterialPassIndex,
                    stateBlock = _renderStateBlock,
                    rendererConfiguration = PerObjectData.None,
                };

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

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

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

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

namespace Example.Graphics
{
    public class CustomRenderFeature : ScriptableRendererFeature
    {
        [Serializable]
        public class Settings
        {
            public string passTag = "CustomPass";
            public string drawTagName = "WriteStencil";
            public RenderPassEvent renderPassEvent = RenderPassEvent.BeforeRenderingOpaques;
            public LayerMask layerMask = ~0;
        }

        public Settings settings = new();
        private CustomRenderPass renderPass;

        public override void Create()
        {
            renderPass = new CustomRenderPass(
                    settings.passTag,
                    settings.drawTagName,
                    settings.renderPassEvent,
                    settings.layerMask
            );
        }

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

            renderer.EnqueuePass(renderPass);
        }
    }
}

Shader "Example/CustomMultipass"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white" {}
        _Color("Color Tint", Color) = (1,1,1,1)
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" }

        // === 패스 1: 스텐실를 작성 ===
        Pass
        {
            Name "WriteStencil"
            Tags { "LightMode" = "WriteStencil" }

            Stencil
            {
                Ref 1
                Comp always
                Pass replace
            }

            ZWrite Off
            ColorMask 0

            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 positionHCS : SV_POSITION;
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS);
                return OUT;
            }

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

        // === 패스 2: 스텐실에 마스킹된 범위만 렌더링 ===
        Pass
        {
            Name "RenderMasked"
            Tags { "LightMode" = "UniversalForward" }

            Stencil
            {
                Ref 1
                Comp equal
                Pass keep
            }

            ZWrite On
            ColorMask RGBA

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            CBUFFER_START(UnityPerMaterial)
                float4 _MainTex_ST;
                float4 _Color;
            CBUFFER_END

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS);
                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
                return texColor * _Color;
            }
            ENDHLSL
        }
    }

    FallBack "Hidden/Shader Graph/FallbackError"
}