【Unity URP】一次对卡通渲染仿动画摄影的探索

            //计算中心点的屏幕坐标
            float2 centerPosSS = ConvertPosWSToScreenUV(_CenterPosWS.xyz);

            //计算中心点的摄像机空间坐标
            float4 centerPosVS = mul(UNITY_MATRIX_V, float4(_CenterPosWS.xyz, 1));

            //在摄像机空间设置Billboard的上边界与右边界
//_LightRampSize为我们设置的新坐标系的单位长度对应摄像机空间的值
//.xy实际设置均为1，若无法理解，忽略即可
            float4 rightPosVS = centerPosVS + float4(_LightRampSize.x, 0, 0, 0);
            float4 topPosVS = centerPosVS + float4(0, _LightRampSize.y, 0, 0);

            //将两个边界的位置都转化为屏幕空间坐标值，使用函数为自定义函数，非Unity自带
            float2 rightPosSS = ConvertPosVSToScreenUV(rightPosVS);
            float2 topPosSS = ConvertPosVSToScreenUV(topPosVS);
            
            //获得屏幕空间下的坐标系“单位长度”
            float lightRampHeight = (topPosSS.y - centerPosSS.y) * 2;
            float lightRampWidth = (rightPosSS.x - centerPosSS.x) * 2;
            
            //正式建立一个坐标系，获取每个像素对应的uv值
            float2 newUV_SS = (scrPos - centerPosSS) / float2(lightRampWidth, lightRampHeight);

//将原点移到“左下角”
newUV_SS = newUV_SS + float2(0.5, 0.5);                
lightDirVS.xy = normalize(lightDirVS.xy);
            float2 newUV_SS = (scrPos - centerPosSS)/float2(lightRampWidth, lightRampHeight) + float2(0.5, 0.5);
            int adjustX = lightDirVS.x > 0 ? 0 : -1;
            
            int adjustY = lightDirVS.y > 0? 0 : -1;
            float lightRamp = dot(lightDirVS.xy, float2(newUV_SS.x + adjustX, newUV_SS.y + adjustY));
            
            return pow(lightRamp, 8) * _LightRampColor;

float2 newUV_SS = (scrPos - centerPosSS) / float2(lightRampWidth, lightRampHeight);

float2 intersectPoint = normalize(lightDirVS.xy) * _RampCircleSize.x;
float lightRamp = max(0, 1 + dot(normalize(lightDirVS.xy), newUV_SS - IntersectPoint));

            //对渐变的计算结果进行一些调整
float4 characterLightRamp = saturate(pow(lightRamp, _LightRampSmoothness)) * _LightRampColor * _LightRampIntensity;
            //计算边缘光
            float rim = pow(saturate(1 - dot(viewDirectionWS, normal)), _RimLightSmoothness);
            float4 addRim = rim * _LightRampColor;
            characterLightRamp.xyz += addRim * smoothstep(0.1, 0.2, length(characterLightRamp));

//影パラ
float darkRamp = saturate(pow(lightRamp, _DarkRampSmoothness));

Shader "Custom/CelShadingWithLightRamp"
{
    Properties
    {
        [MainTexture]_BaseMap ("Base Map", 2D) = "white" { }
        _BaseColor ("Base Color", Color) = (0, 0.66, 0.73, 1)
        
        [Header(Shading)]
        _BrightColor ("BrightColor", Color) = (1, 1, 1, 1)
        [HDR]_MiddleColor ("MiddleColor", Color) = (0.8, 0.1, 0.1, 1)
        _DarkColor ("DarkColor", Color) = (0.5, 0.5, 0.5, 1)
        _CelShadeMidPoint ("CelShadeMidPoint", Range(0, 1)) = 0.5
        _CelShadeSmoothness ("CelShadeSmoothness", Range(0, 1)) = 0.1
        [Toggle(_IsFace)] _IsFace ("IsFace", Float) = 0.0
        _HairShadowDistace ("_HairShadowDistance", Float) = 0.008
        
        [Header(Rim)]
        _RimColor ("RimColor", Color) = (1, 1, 1, 1)
        _RimSmoothness ("RimSmoothness", Range(0, 10)) = 10
        _RimStrength ("RimStrength", Range(0, 1)) = 0.1
        
        [Header(OutLine)]
        _OutLineColor ("OutLineColor", Color) = (0, 0, 0, 1)
        _OutLineThickness ("OutLineThickness", float) = 0.5
        [Toggle(_UseColor)] _UseColor ("UseVertexColor", Float) = 0.0
        
        [Header(heightCorrectMask)]
        _HeightCorrectMax ("Height Correct Mask", float) = 1.6
        _HeightCorrectMin ("Height Correct Min", float) = 1.51
        
        [Header(LightRamp)]
        [Toggle(_UseLightRamp)] _UseLightRamp ("Use Light Ramp", Float) = 0.0
        _LightRampSize ("Light Ramp Size", Vector) = (1, 1, 0, 0)
        _LightRampColor ("Light Ramp Color", Color) = (1, 1, 1, 1)
        _RampCircleSize ("Ramp Circle Size", Vector) = (0.84, 1.3, 0, 0)
        _LightRampSmoothness ("Light Ramp Smoothness", Range(0, 20)) = 9.7
        _LightRampIntensity ("Light Ramp Intensity", Range(0, 20)) = 7.3
        _DarkRampSmoothness ("Dark Ramp Smoothness", Range(0, 10)) = 1.5
        _DarkRampIntensity ("Dark Ramp Intensity", Range(0, 1)) = 1
        _RimLightSmoothness ("Rim Light Smoothness", Range(0, 10)) = 3
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalRenderPipeline" }
        
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
        
        #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
        #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
        #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
        #pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS
        #pragma multi_compile _ _SHADOWS_SOFT
        
        
        CBUFFER_START(UnityPerMaterial)
        float4 _BaseMap_ST;
        float4 _BaseColor, _BrightColor, _DarkColor, _OutLineColor, _MiddleColor, _RimColor;
        float _CelShadeMidPoint, _CelShadeSmoothness, _OutLineThickness;
        float _RimSmoothness, _RimStrength, _HairShadowDistace, _HeightCorrectMax, _HeightCorrectMin;
        float4 _CenterPosWS, _LightRampSize, _LightRampColor, _RampCircleSize;
        float _LightRampSmoothness, _LightRampIntensity, _DarkRampSmoothness, _DarkRampIntensity;
        float _RimLightSmoothness;
        CBUFFER_END
        ENDHLSL
        
        Pass
        {
            Name "BaseCel"
            Tags { "LightMode" = "UniversalForward" }
            
            Cull off
            
            HLSLPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            
            #pragma multi_compile _UseLightRampOff _UseLightRamp
            #pragma multi_compile _NotOnlyLightRamp _OnlyLightRamp
            #pragma shader_feature _IsFace
            
            
            struct a2v
            {
                float4 positionOS: POSITION;
                float2 uv: TEXCOORD0;
                float4 normal: NORMAL;
                float3 color: COLOR;
            };
            
            struct v2f
            {
                float4 positionCS: SV_POSITION;
                float2 uv: TEXCOORD0;
                float3 positionWS: TEXCOORD1;
                float3 normal: TEXCOORD2;
                float4 positionSS: TEXCOORD3;
                #if _IsFace
                    float posNDCw: TEXCOORD4;
                    float4 positionOS: TEXCOORD5;
                #endif
                float3 color: TEXCOORD6;
            };
            
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            TEXTURE2D(_HairSoildColor);
            SAMPLER(sampler_HairSoildColor);
            //TEXTURE2D(_LightRampColor);
            //SAMPLER(sampler_LightRampColor);
            
            
            v2f vert(a2v v)
            {
                v2f o;
                
                VertexPositionInputs positionInputs = GetVertexPositionInputs(v.positionOS.xyz);
                o.positionCS = positionInputs.positionCS;
                o.positionWS = positionInputs.positionWS;
                o.positionSS = ComputeScreenPos(positionInputs.positionCS);
                
                #if _IsFace
                    o.posNDCw = positionInputs.positionNDC.w;
                    o.positionOS = v.positionOS;
                #endif
                
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                
                VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(v.normal);
                o.normal = vertexNormalInput.normalWS;
                
                
                o.color = v.color;
                return o;
            }
            
            float2 ConvertPosWSToScreenUV(float3 posWS)
            {
                float4 posCS = mul(UNITY_MATRIX_VP, float4(posWS, 1));//posWS -> posCS
                float2 posNDCxy = posCS .xy / posCS .w;//posCS -> posNDC
                float2 screenUV = posNDCxy * 0.5 + 0.5; //posNDC -> screen [0,1] uv
                screenUV.y = 1 - screenUV.y;
                return screenUV;
            }
            
            float2 ConvertPosVSToScreenUV(float4 posVS)
            {
                float4 posCS = mul(UNITY_MATRIX_P, posVS);//posVS -> posCS
                float2 posNDCxy = posCS .xy / posCS .w;//posCS -> posNDC
                float2 screenUV = posNDCxy * 0.5 + 0.5; //posNDC -> screen [0,1] uv
                screenUV.y = 1 - screenUV.y;
                return screenUV;
            }
            
            float SubsurfaceScattering(float3 viewDir, float3 lightDir, float3 normalDir,
            float frontSubsurfaceDistortion, float backSubsurfaceDistortion, float frontSSSIntensity, float thickness)
            {
                //分别计算正面和反面的次表面散射
                float3 frontLitDir = normalDir * frontSubsurfaceDistortion - lightDir;
                float3 backLitDir = normalDir * backSubsurfaceDistortion + lightDir;
                float frontsss = saturate(dot(viewDir, -frontLitDir));
                float backsss = saturate(dot(viewDir, -backLitDir));
                
                float result = saturate(frontsss * frontSSSIntensity + backsss) * thickness;
                return result;
            }
            
            //Ray must through point(0, 0)
            float2 GetRayIntersectWithSqure(float2 squareWidHei, float2 rayDir)
            {
                float K = rayDir.y / rayDir.x;
                
                float2 verticalLine1Point = float2(-squareWidHei.y / 2, -squareWidHei.y / 2 * K);
                float2 horizonalLine1Point = float2(squareWidHei.x / K / 2, squareWidHei.x / 2);
                float2 horizonalLine2Point = float2(-squareWidHei.x / K / 2, -squareWidHei.x / 2);
                
                float2 horizonalLinePoint = K > 0 ? horizonalLine2Point: horizonalLine1Point;
                
                float2 leftPoint;
                float2 rightPoint;
                
                if (length(verticalLine1Point) < length(horizonalLinePoint))
                {
                    leftPoint = verticalLine1Point;
                    rightPoint = -verticalLine1Point;
                }
                
                else
                {
                    leftPoint = horizonalLinePoint;
                    rightPoint = -horizonalLinePoint;
                }
                
                float2 returnPoint = rayDir.x > 0 ? rightPoint: leftPoint;
                
                return returnPoint;
            }
            
            float2 GetRayIntersectWithCircle(float2 radiusAndHeight, float2 rayDir)
            {
                float K = rayDir.y / rayDir.x;
                float r = radiusAndHeight.x / 2;
                float rightPointX = sqrt(r * r / (K * K + 1));
                
                
                float2 rightPoint = float2(rightPointX, K * rightPointX);
                float2 leftPoint = -rightPoint;
                
                float2 returnPoint = rayDir.x > 0 ? rightPoint: leftPoint;
                returnPoint.y *= radiusAndHeight.y;
                return returnPoint;
            }
            
            float fit01(float minValue, float maxValue, float value)
            {
                return saturate((value - minValue) / (maxValue - minValue));
            }
            
            
            half4 frag(v2f i): SV_Target
            {
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
                float4 shadowCoord = TransformWorldToShadowCoord(i.positionWS.xyz);
                Light light = GetMainLight(shadowCoord);
                float3 normal = normalize(i.normal);
                
                //receive shadow-------------
                Light mainLight;
                #if _MAIN_LIGHT_SHADOWS
                    mainLight = GetMainLight(TransformWorldToShadowCoord(i.positionWS));
                #else
                    mainLight = GetMainLight();
                #endif
                real shadow = mainLight.shadowAttenuation * mainLight.distanceAttenuation;
                
                //basic cel shading-------------
                float CelShadeMidPoint = _CelShadeMidPoint;
                float halfLambert = dot(normal, light.direction) * 0.5 + 0.5;
                half ramp = smoothstep(0, CelShadeMidPoint, pow(saturate(halfLambert - CelShadeMidPoint), _CelShadeSmoothness));
                
                float2 scrPos = i.positionSS.xy / i.positionSS.w;
                //face shadow-------------
                #if _IsFace
                    //we are not use heightCorrect in this sample
                    float heightCorrect = smoothstep(_HeightCorrectMax, _HeightCorrectMin, i.positionWS.y);
                    //return heightCorrect;
                    
                    
                    float4 scaledScreenParams = GetScaledScreenParams();
                    float3 viewLightDir = normalize(TransformWorldToViewDir(mainLight.direction)) * (1 / i.posNDCw) ;
                    
                    float2 samplingPoint = scrPos + _HairShadowDistace * viewLightDir.xy * float2(1, scaledScreenParams.x / scaledScreenParams.y);
                    
                    //if (depth =  z/w * 0.5 + 0.5), we will have a float precision problem
                    //but it's just right when we are far away from character to hide the shadow
                    float depth = (i.positionCS.z / i.positionCS.w);
                    float hairDepth = SAMPLE_TEXTURE2D(_HairSoildColor, sampler_HairSoildColor, samplingPoint).g;
                    
                    float depthCorrect = depth/* * heightCorrect*/ < hairDepth + 0.001 ? 0: 1;
                    //return depthCorrect;
                    
                    //float hairShadow = 1 - SAMPLE_TEXTURE2D(_HairSoildColor, sampler_HairSoildColor, samplingPoint).r;
                    //0为影，1为非影
                    float hairShadow = lerp(0, 1, depthCorrect);
                    ramp *= hairShadow;
                #else
                    
                    //ramp *= shadow;
                    
                #endif
                
                
                half3 diffuse = lerp(_DarkColor.xyz, _BrightColor.xyz, ramp);
                diffuse *= baseMap.xyz;
                
                //rim light-------------
                half3 viewDirectionWS = SafeNormalize(GetCameraPositionWS() - i.positionWS.xyz);
                float rimStrength = pow(saturate(1 - dot(normal, viewDirectionWS)), _RimSmoothness);
                float3 rimColor = _RimColor.xyz * rimStrength * _RimStrength;
                
                //Character Light Ramp-------------
                //计算中心点的屏幕坐标
                float2 centerPosSS = ConvertPosWSToScreenUV(_CenterPosWS.xyz);
                //计算中心点的摄像机空间坐标
                float4 centerPosVS = mul(UNITY_MATRIX_V, float4(_CenterPosWS.xyz, 1));
                //在摄像机空间设置Billboard的上边界与右边界
                float4 rightPosVS = centerPosVS + float4(_LightRampSize.x, 0, 0, 0);
                float4 topPosVS = centerPosVS + float4(0, _LightRampSize.y, 0, 0);
                //将两个边界的位置都转化为屏幕空间坐标值
                float2 rightPosSS = ConvertPosVSToScreenUV(rightPosVS);
                float2 topPosSS = ConvertPosVSToScreenUV(topPosVS);
                
                //获得屏幕空间下的坐标系“单位长度”
                float lightRampHeight = (topPosSS.y - centerPosSS.y) * 2;
                float lightRampWidth = (rightPosSS.x - centerPosSS.x) * 2;
                
                
                float3 lightDirVS = normalize(TransformWorldToViewDir(mainLight.direction));
                
                
                //----------Method 1----------
                // float2 newUV_SS = (scrPos - centerPosSS)/float2(lightRampWidth, lightRampHeight) + float2(0.5, 0.5);
                // int adjustX = lightDirVS.x > 0 ? 0 : -1;
                
                // int adjustY = lightDirVS.y > 0? 0 : -1;
                // float lightRamp = dot(lightDirVS.xy, float2(newUV_SS.x + adjustX, newUV_SS.y + adjustY));
                
                
                // return pow(lightRamp, 8) * _LightRampColor;
                
                // float4 characterLightRamp = SAMPLE_TEXTURE2D(_LightRampColor, sampler_LightRampColor, scrPos);
                
                //return darkRamp;
                
                //----------Method 2----------
                
                // float2 newUV_SS = (scrPos - centerPosSS) / float2(lightRampWidth, lightRampHeight);
                // float2 IntersectPoint = GetRayIntersectWithSqure(_RampCircleSize.xy, lightDirVS.xy);
                
                // float K = -lightDirVS.x / lightDirVS.y;
                // float A = 1;
                // float B = -K;
                // float C = K * IntersectPoint.x - IntersectPoint.y;
                // float lightRamp = 1 - abs(A * newUV_SS.y + B * newUV_SS.x + C) / sqrt(A * A + B * B);
                // return lightRamp;
                
                //----------Method 3----------
                float2 newUV_SS = (scrPos - centerPosSS) / float2(lightRampWidth, lightRampHeight);
                
                
                float2 IntersectPoint = normalize(lightDirVS.xy) * _RampCircleSize.x / 2;
                IntersectPoint.y *= _RampCircleSize.y;
                //float2 IntersectPoint = GetRayIntersectWithCircle(_RampCircleSize.xy);
                //点到直线的距离
                // float K = -lightDirVS.x / lightDirVS.y;
                // float A = 1;
                // float B = -K;
                // float C = K * IntersectPoint.x - IntersectPoint.y;
                // float lightRamp = 1 - abs(A * newUV_SS.y + B * newUV_SS.x + C) / sqrt(A * A + B * B);
                
                float lightRamp = max(0, 1 + dot(normalize(lightDirVS.xy), newUV_SS - IntersectPoint));
                
                //---------------------------------
                float4 characterLightRamp = saturate(pow(lightRamp, _LightRampSmoothness)) * _LightRampColor * _LightRampIntensity;
                
                //Highlight
                float rim = pow(saturate(1 - dot(viewDirectionWS, normal)), _RimLightSmoothness);
                float4 addRim = rim * _LightRampColor;
                characterLightRamp.xyz += addRim.xyz * smoothstep(0.1, 0.2, length(characterLightRamp));
                
                //影パラ
                float darkRamp = saturate(pow(lightRamp, _DarkRampSmoothness));
                darkRamp = lerp(1, darkRamp, _DarkRampIntensity);
                
                #if _OnlyLightRamp
                    return characterLightRamp;
                #endif
                
                
                #if _UseLightRamp
                    float4 finCol = float4(diffuse + rimColor + characterLightRamp.xyz, 1);
                    return finCol * darkRamp;
                #else
                    return float4(diffuse + rimColor, 1);
                #endif
            }
            ENDHLSL
            
        }
        
        Pass
        {
            Name "OutLine"
            Cull Front
            ZWrite On
            
            HLSLPROGRAM
            
            #pragma shader_feature _UseColor
            #pragma vertex vert
            #pragma fragment frag
            
            struct a2v
            {
                float4 positionOS: POSITION;
                float4 normalOS: NORMAL;
                float4 tangentOS: TANGENT;
                #if _UseColor
                    float3 color: COLOR;
                #endif
            };
            
            struct v2f
            {
                float4 positionCS: SV_POSITION;
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                
                VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(v.normalOS, v.tangentOS);
                
                #if _UseColor
                    float3 color = v.color * 2 - 1;
                    
                    VertexPositionInputs positionInputs = GetVertexPositionInputs(v.positionOS.xyz + float3(color.xy * 0.001 * _OutLineThickness, 0));
                    o.positionCS = positionInputs.positionCS/* + float4(color.xy * 0.001 * _OutLineThickness * positionInputs.positionCS.w, 0, 0)*/;
                #else
                    float3 normalWS = vertexNormalInput.normalWS;
                    float3 normalCS = TransformWorldToHClipDir(normalWS);
                    
                    VertexPositionInputs positionInputs = GetVertexPositionInputs(v.positionOS.xyz);
                    o.positionCS = positionInputs.positionCS + float4(normalCS.xy * 0.001 * _OutLineThickness * positionInputs.positionCS.w, 0, 0);
                #endif
                
                
                
                return o;
            }
            
            half4 frag(v2f i): SV_Target
            {
                float4 col = _OutLineColor;
                
                return col;
            }
            ENDHLSL
            
        }
        
        //This Pass copy from https://github.com/ColinLeung-NiloCat/UnityURPToonLitShaderExample
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }
            
            //we don't care about color, we just write to depth
            ColorMask 0
            
            HLSLPROGRAM
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            
            #pragma vertex ShadowCasterPassVertex
            #pragma fragment ShadowCasterPassFragment
            
            struct Attributes
            {
                float3 positionOS: POSITION;
                half3 normalOS: NORMAL;
                half4 tangentOS: TANGENT;
                float2 uv: TEXCOORD0;
            };
            
            struct Varyings
            {
                float2 uv: TEXCOORD0;
                float4 positionWSAndFogFactor: TEXCOORD2; // xyz: positionWS, w: vertex fog factor
                half3 normalWS: TEXCOORD3;
                
                #ifdef _MAIN_LIGHT_SHADOWS
                    float4 shadowCoord: TEXCOORD6; // compute shadow coord per-vertex for the main light
                #endif
                float4 positionCS: SV_POSITION;
            };
            
            Varyings ShadowCasterPassVertex(Attributes input)
            {
                Varyings output;
                
                // VertexPositionInputs contains position in multiple spaces (world, view, homogeneous clip space)
                // Our compiler will strip all unused references (say you don't use view space).
                // Therefore there is more flexibility at no additional cost with this struct.
                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS);
                
                // Similar to VertexPositionInputs, VertexNormalInputs will contain normal, tangent and bitangent
                // in world space. If not used it will be stripped.
                VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                
                // Computes fog factor per-vertex.
                float fogFactor = ComputeFogFactor(vertexInput.positionCS.z);
                
                // TRANSFORM_TEX is the same as the old shader library.
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                
                // packing posWS.xyz & fog into a vector4
                output.positionWSAndFogFactor = float4(vertexInput.positionWS, fogFactor);
                output.normalWS = vertexNormalInput.normalWS;
                
                #ifdef _MAIN_LIGHT_SHADOWS
                    // shadow coord for the light is computed in vertex.
                    // After URP 7.21, URP will always resolve shadows in light space, no more screen space resolve.
                    // In this case shadowCoord will be the vertex position in light space.
                    output.shadowCoord = GetShadowCoord(vertexInput);
                #endif
                
                // Here comes the flexibility of the input structs.
                // We just use the homogeneous clip position from the vertex input
                output.positionCS = vertexInput.positionCS;
                
                // ShadowCaster pass needs special process to clipPos, else shadow artifact will appear
                //--------------------------------------------------------------------------------------
                
                //see GetShadowPositionHClip() in URP/Shaders/ShadowCasterPass.hlsl
                float3 positionWS = vertexInput.positionWS;
                float3 normalWS = vertexNormalInput.normalWS;
                
                
                Light light = GetMainLight();
                float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, light.direction));
                
                #if UNITY_REVERSED_Z
                    positionCS.z = min(positionCS.z, positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    positionCS.z = max(positionCS.z, positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #endif
                output.positionCS = positionCS;
                
                //--------------------------------------------------------------------------------------
                
                return output;
            }
            
            half4 ShadowCasterPassFragment(Varyings input): SV_TARGET
            {
                return 0;
            }
            
            ENDHLSL
            
        }
        
        //This Pass copy from https://cyangamedev.wordpress.com/2020/06/05/urp-shader-code/10/
        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode" = "DepthOnly" }
            
            ZWrite On
            ColorMask 0
            
            HLSLPROGRAM
            
            // Required to compile gles 2.0 with standard srp library
            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x gles
            //#pragma target 4.5
            
            // Material Keywords
            #pragma shader_feature _ALPHATEST_ON
            #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            
            // GPU Instancing
            #pragma multi_compile_instancing
            #pragma multi_compile _ DOTS_INSTANCING_ON
            
            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment
            
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
            
            // Again, using this means we also need _BaseMap, _BaseColor and _Cutoff shader properties
            // Also including them in cbuffer, except _BaseMap as it's a texture.
            
            ENDHLSL
            
        }
    }
}