URP中Shader获取屏幕信息_CameraOpaqueTexture

1.URP管线下Bulidin中的GrabPass是失效的；

2.URP中对应的是_CameraOpaqueTexture;

使用方法如下：

//YJJ:2023.11.15          
Shader "Common/Show/Glass"
{
    Properties
    {   
        [Header(Option)]
        [Enum(Off, 0, On, 1)]_ZWriteMode ("ZWriteMode", float) = 0
        [Enum(UnityEngine.Rendering.CompareFunction)]_ZTestMode ("ZTestMode", Float) = 4
        [Header(Custom)]

        _BaseColor("Base Color",color) = (1,1,1,1)
        //笑死个人，[MainTexture]这一行还不能删，否则烘焙光照会有问题，哪怕你没贴图也得贴个通道贴图
        // _CubeMap ("Reflection Cubemap", Cube) = "_Skybox" {}
        [MainTexture]_BaseMap("透明度Mask(光照Mask专用)", 2D) = "white" {}

        _BumpMap("NormalMap",2D)="bump"{}
        _NormalScale("NormalPow", Range(0.0, 1.0)) = 1.0
    }
    //----------------------获取_CameraOpaqueTexture---------------------------------
     HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        struct appdata
        {
            float4 positionOS : POSITION;
            float2 texcoord : TEXCOORD0;
            float4 vertexColor : COLOR;
        };
        struct v2f
        {
            float2 uv : TEXCOORD0;
            float4 positionOS : SV_POSITION;
            float4 vertexColor : COLOR;
        };
        SAMPLER(_CameraOpaqueTexture);                   //定义贴图
    ENDHLSL
    //----------------------------END-----------------------------------------------------
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue" = "Transparent"  "RenderPipeline"="UniversalPipeline" "IgnoreProjector" = " True" }
        Blend SrcAlpha OneMinusSrcAlpha
        //关闭深度//关闭深度玻璃没那么完美
		ZWrite [_ZWriteMode]
        ZTest [_ZTestMode]
        ZWrite off
        //Blend SrcAlpha One

        Pass
        {   Tags{ "LightMode"="UniversalForward" }
            Name "Diffuse"
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fog
            #pragma shader_feature _ _KALOS_G_FACTOR_ON

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"


            CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            float4 _BaseMap_ST,_BumpMap_ST;
            float4 _ShadowMainColor;
            float  _NormalScale;
            CBUFFER_END
            TEXTURE2D (_BumpMap);           SAMPLER(sampler_BumpMap); 
            TEXTURE2D (_BaseMap);           SAMPLER(sampler_BaseMap); 
            // samplerCUBE _CubeMap;        
            // float4 _CubeMap_HDR;
            // SAMPLER(sampler_CubeMap);
            
            //SAMPLER(_CameraOpaqueTexture);          //玻璃
 
            struct VertexInput
            {
                float4 positionOS       : POSITION;
                float2 uv               : TEXCOORD0;
				float4 normalOS         : NORMAL;
				float4 tangentOS        : TANGENT;
                float4 vertexColor      : COLOR;
            };
 
            struct VertexOutput
            {
                float4 position         : SV_POSITION;
                float4 uv               : TEXCOORD0;
				float3 positionWS       :  TEXCOORD1;
				float3 normalWS         : TEXCOORD2;
				float3 tangentWS        : TEXCOORD3;
				float3 bitangentWS      : TEXCOORD4;
                float fogCoord          : TEXCOORD5;
                float4 vertexColor      : COLOR;
            };

            half3 Saturation(half3 BlendCol, half Saturation)
            {
                half   gray        = 0.2125 * BlendCol.r + 0.7154 * BlendCol.g + 0.0721 * BlendCol.b;
                half3  grayColor   = half3(gray, gray, gray);
                return lerp(grayColor, BlendCol, Saturation);
            }

             
            VertexOutput vert(VertexInput v)
            {
                VertexOutput o = (VertexOutput)0;

				VertexPositionInputs positionInputs = GetVertexPositionInputs(v.positionOS.xyz);
                o.position = positionInputs.positionCS;
				o.positionWS = positionInputs.positionWS; 

				VertexNormalInputs normalInputs = GetVertexNormalInputs(v.normalOS.xyz,v.tangentOS);
				o.normalWS = normalInputs.normalWS;
				o.tangentWS = normalInputs.tangentWS;
				o.bitangentWS = normalInputs.bitangentWS;

                o.uv.xy = TRANSFORM_TEX(v.uv, _BumpMap);

                o.vertexColor = v.vertexColor;
                o.fogCoord = ComputeFogFactor(o.position.z);
 
                return o;
            }
 
            half4 frag(VertexOutput i) : SV_Target
            {
                //阴影
                Light  lightDirectional     = GetMainLight();

                //贴图采样
                half4  BaseMap      = SAMPLE_TEXTURE2D(_BaseMap,sampler_BaseMap,i.uv.xy);
                //half3  normalMap    = UnpackNormal(SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,i.uv.xy));
                half4  normalTXS    = SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,i.uv.xy);
                float3 normalMap    = UnpackNormalScale(normalTXS,_NormalScale);
                
                //法线计算
                    real3x3 TBN      = real3x3(i.tangentWS, i.bitangentWS, i.normalWS);    //追求高精度
                    //half3 normalWS   = mul(normalMap,TBN);
                    half3 normalWS   = TransformTangentToWorld(normalMap,TBN);

                //向量准备
                half3 N = normalWS;
                
                half3 L = normalize(lightDirectional.direction);
                half3 V = SafeNormalize(_WorldSpaceCameraPos - i.positionWS);
                half3 H = normalize(L + V);

                //点积
                half  HdotL = max(dot(H, L), 1e-5);
                half  NdotV = max(dot(N, V), 1e-5);         //此处会有黑斑bug
                half  HdotN = max(dot(H, N), 1e-5);
                half  NdotL = dot(N,L);

                half3 R     = reflect( -L , N );
                half  VdotR = dot ( V , R );

                //float3 reflectDirWS = reflect(-V,N);
                //half4 Cube = texCUBE(_CubeMap,reflectDirWS);            // 使用反射向量采样环境贴图

                half2 screenUV = (i.position.xy / _ScreenParams.xy) + half2(normalMap.rg  * i.vertexColor.a);
                half4 crashTex = tex2Dlod(_CameraOpaqueTexture,float4(screenUV , 0 , 7));
                return crashTex;
                
            }
            ENDHLSL
        }
        //UsePass "Universal Render Pipeline/Lit/ShadowCaster"

        UsePass "Universal Render Pipeline/Lit/DepthOnly"  
    }
}

里面有冗余代码，请自行删减；