metaverse_artist/Lux URP Essentials/Shaders/Human/Toon.shader

// Shader uses custom editor to set double sided GI
// Needs _Culling to be set properly


Shader "Toon"
{
	Properties
	{
		[HeaderHelpLuxURP_URL(snoamqpqhtdl)]

		[Header(Surface Options)]
		[Space(8)]
		[ToggleOff(_RECEIVE_SHADOWS_OFF)]
		_ReceiveShadows("Receive Shadows", Float) = 1.0
		_SkinShadowBias("     Shadow Caster Bias", Range(.1, 1.0)) = 1.0
		_SkinShadowSamplingBias("     Shadow Sampling Bias", Range(0, 0.05)) = 0

		[Header(Surface Inputs)]
		[Space(8)]
		[MainTexture]
		_BaseMap("Albedo (RGB) Smoothness (A)", 2D) = "white" {}
		_ClothMask1("Cloth Mask1", 2D) = "white" {}
		_ClothMask2("Cloth Mask2", 2D) = "white" {}
		_ClothMask3("Cloth Mask3", 2D) = "white" {}
		[MainColor]
		_BaseColor("Color", Color) = (1,1,1,1)

		[Space(5)]
		_Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
	//  For some reason android did not like _SpecColor!?
		_SpecularColor("Specular", Color) = (0.2, 0.2, 0.2)
	
		[Space(5)]
		[Toggle(_NORMALMAP)]
		_ApplyNormal("Enable Normal Map", Float) = 0.0
		[NoScaleOffset]
		_BumpMap("     Normal Map", 2D) = "bump" {}
		_BumpScale("     Normal Scale", Float) = 1.0
		[Toggle(_NORMALMAPDIFFUSE)]
		_ApplyNormalDiffuse("     Enable Diffuse Normal Sample", Float) = 0.0
		_Bias("     Bias", Range(0.0, 8.0)) = 3.0
		[Toggle]_VertexNormal("          Use Vertex Normal for Diffuse", Float) = 1

		_SSSMap("SSS Map", 2D) = "black" {}
		_ILMMap("ILM Map",2D) = "gray" {}
		_DetailMap("Detail Map",2D) = "white" {}
		_ToonThesHold("ToonThesHold",Range(0,1)) = 0.5
		_ToonHardness("ToonHardness",Float) = 20.0
		_SpecColor("Spec Color",Color) = (1,1,1,1)
		_SpecSize("Spec Size",Range(0,1)) = 0.1
		_RimLightDir("RimLight Dir",Vector) = (1,0,-1,0)
		_RimLightColor("RimLight Color",Color) = (1,1,1,1)
		_OutlineWidth("Outline Width",Float) = 7.0
		_OutlineZbias("Outline Zbias",Float) = -10
		_OutlineColor("Outline Color",Color) = (1,1,1,1)
		
		[Header(Mask)]
		[Space(8)]
		_MakeUpMask1_RGB("MakeUpMask1_RGB (R: 眼影 G: 腮红 B: 口红 A: 眼线）", 2D) = "black" {}
		_MakeUpMask2_RGB("MakeUpMask2_RGB (R: 纹身区域)", 2D) = "black" {}
		_Mask1_Rchannel_TextureAmountA("Mask1_Rchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask1_Gchannel_TextureAmountA("Mask1_Gchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask1_Bchannel_TextureAmountA("Mask1_Bchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask2_Rchannel_TextureAmountA("Mask2_Rchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask2_Gchannel_TextureAmountA("Mask2_Gchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask2_Bchannel_TextureAmountA("Mask2_Bchannel_Texture-Amount(A)", 2D) = "black" {}
		_Mask1_Rchannel_ColorAmountA("Mask1_Rchannel_Color-Amount(A)", Color) = (0.7735849, 0.2006942, 0.3233189, 0.7843137)
		_Mask1_Gchannel_ColorAmountA("Mask1_Gchannel_Color-Amount(A)", Color) = (0.2, 0.772549, 0.4917381, 0.7843137)
		_Mask1_Bchannel_ColorAmountA("Mask1_Bchannel_Color-Amount(A)", Color) = (0.2, 0.406334, 0.772549, 0.7843137)
		_Mask1_Achannel_ColorAmountA("Mask1_Achannel_Color-Amount(A)", Color) = (0.2, 0.406334, 0.772549, 0.7843137)
		_Mask2_Rchannel_ColorAmountA("Mask2_Rchannel_Color-Amount(A)", Color) = (0.2, 0.772549, 0.7071339, 0.7843137)
		_Mask2_Gchannel_ColorAmountA("Mask2_Gchannel_Color-Amount(A)", Color) = (0.772549, 0.2, 0.6776864, 0.7843137)
		_Mask2_Bchannel_ColorAmountA("Mask2_Bchannel_Color-Amount(A)", Color) = (0.772549, 0.7037676, 0.2, 0.7843137)

	//  Needed by the inspector
		[HideInInspector] _Culling("Culling", Float) = 0.0

	//  Lightmapper and outline selection shader need _MainTex, _Color and _Cutoff
		[HideInInspector] _MainTex("Albedo", 2D) = "white" {}
		[HideInInspector] _Color("Color", Color) = (1,1,1,1)
		[HideInInspector] _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.0

    //  URP 10.1. needs this for the depthnormal pass 
		[HideInInspector] _Cutoff("     Threshold", Range(0.0, 1.0)) = 0.5
		[HideInInspector] _Surface("__surface", Float) = 0.0

	}
	SubShader
	{
		   Tags
		{
			"RenderPipeline" = "UniversalPipeline"
			"RenderType" = "Opaque"
			"Queue" = "Geometry"
		}
		LOD 100

		Pass
		{
			Tags { "LightMode" = "UniversalForward" }
			HLSLPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
			#pragma multi_compile_fragment _ _SHADOWS_SOFT
			#pragma multi_compile _ _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
			//#pragma multi_compile_fwdbase
			//#include "UnityCG.cginc"
			//#include "AutoLight.cginc"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
			#include "Includes/Lux URP Skin Inputs Custom Toon.hlsl"

			struct Attritubes
			{
				float4 positionOS : POSITION;
				float2 texcoord0 : TEXCOORD0;
				float2 texcoord1 : TEXCOORD1;
				float3 normalOS : NORMAL;
				float4 color : COLOR;
			};

			struct Varyings
			{
				float4 positionCS : SV_POSITION;
				float4 uv : TEXCOORD0;
				float3 positionWS : TEXCOORD1;
				float3 normalWS : TEXCOORD2;
				float4 vertexColor : TEXCOORD3;
				float4 shadowCoord : TEXCOORD4;
			};

			//TEXTURE2D(_BaseMap);	SAMPLER(sampler_BaseMap);
			TEXTURE2D(_SSSMap);		SAMPLER(sampler_SSSMap);
			TEXTURE2D(_ILMMap);		SAMPLER(sampler_ILMMap);
			TEXTURE2D(_DetailMap);	SAMPLER(sampler_DetailMap);

			/*CBUFFER_START(UnityPerMaterial)
			float _ToonThesHold;
			float _ToonHardness;
			float4 _SpecColor;
			float _SpecSize;
			float4 _RimLightDir;
			float4 _RimLightColor;
			CBUFFER_END*/
			
			Varyings vert (Attritubes input)
			{
				Varyings output = (Varyings)0;
				VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
				output.positionCS = vertexInput.positionCS;
				output.positionWS = vertexInput.positionWS;
				//output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
				//output.positionWS = TransformObjectToWorld(input.positionOS.xyz);
				output.normalWS = TransformObjectToWorldNormal(input.normalOS);
				output.uv = float4(input.texcoord0,input.texcoord1);
				output.vertexColor = input.color;
				output.shadowCoord = GetShadowCoord(vertexInput);

				return output;
			}

			half4 GetColor(float2 uv) {
				//half4 albedoAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)) * _BaseColor;
				half4 albedoAlpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv * _BaseMap_ST.xy + _BaseMap_ST.zw) * _BaseColor;
				//--------------------------------------------------------
				float2 uv_MakeUpMask1_RGB = uv.xy * _MakeUpMask1_RGB_ST.xy + _MakeUpMask1_RGB_ST.zw;
				float4 tex2DNode143 = SAMPLE_TEXTURE2D(_MakeUpMask1_RGB, sampler_MakeUpMask1_RGB, uv_MakeUpMask1_RGB);


				float2 uv_Mask1_Rchannel_TextureAmountA = uv.xy * _Mask1_Rchannel_TextureAmountA_ST.xy + _Mask1_Rchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask1_R = SAMPLE_TEXTURE2D(_Mask1_Rchannel_TextureAmountA, sampler_Mask1_Rchannel_TextureAmountA, uv_Mask1_Rchannel_TextureAmountA);

				float2 uv_Mask1_Gchannel_TextureAmountA = uv.xy * _Mask1_Gchannel_TextureAmountA_ST.xy + _Mask1_Gchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask1_G = SAMPLE_TEXTURE2D(_Mask1_Gchannel_TextureAmountA, sampler_Mask1_Gchannel_TextureAmountA, uv_Mask1_Gchannel_TextureAmountA);

				float2 uv_Mask1_Bchannel_TextureAmountA = uv.xy * _Mask1_Bchannel_TextureAmountA_ST.xy + _Mask1_Bchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask1_B = SAMPLE_TEXTURE2D(_Mask1_Bchannel_TextureAmountA, sampler_Mask1_Bchannel_TextureAmountA, uv_Mask1_Bchannel_TextureAmountA);

				float2 uv_Mask1_Achannel_TextureAmountA = uv.xy * _Mask1_Achannel_TextureAmountA_ST.xy + _Mask1_Achannel_TextureAmountA_ST.zw;
				float4 tex2D_mask1_A = SAMPLE_TEXTURE2D(_Mask1_Bchannel_TextureAmountA, sampler_Mask1_Bchannel_TextureAmountA, uv_Mask1_Achannel_TextureAmountA);

				float2 uv_Mask2_Rchannel_TextureAmountA = uv.xy * _Mask2_Rchannel_TextureAmountA_ST.xy + _Mask2_Rchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask2_R = SAMPLE_TEXTURE2D(_Mask2_Rchannel_TextureAmountA, sampler_Mask2_Rchannel_TextureAmountA, uv_Mask2_Rchannel_TextureAmountA);

				float2 uv_Mask2_Gchannel_TextureAmountA = uv.xy * _Mask2_Gchannel_TextureAmountA_ST.xy + _Mask2_Gchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask2_G = SAMPLE_TEXTURE2D(_Mask2_Gchannel_TextureAmountA, sampler_Mask2_Gchannel_TextureAmountA, uv_Mask2_Gchannel_TextureAmountA);

				float2 uv_Mask2_Bchannel_TextureAmountA = uv.xy * _Mask2_Bchannel_TextureAmountA_ST.xy + _Mask2_Bchannel_TextureAmountA_ST.zw;
				float4 tex2D_mask2_B = SAMPLE_TEXTURE2D(_Mask2_Bchannel_TextureAmountA, sampler_Mask2_Bchannel_TextureAmountA, uv_Mask2_Bchannel_TextureAmountA);

				float clampResult295 = clamp((tex2DNode143.r * tex2D_mask1_R.a * _Mask1_Rchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask1_R_Color = tex2D_mask1_R * _Mask1_Rchannel_ColorAmountA;
				float4 lerpResult145 = lerp(albedoAlpha, _Mask1_R_Color, clampResult295);

				float clampResult296 = clamp((tex2DNode143.g * tex2D_mask1_G.a * _Mask1_Gchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask1_G_Color = tex2D_mask1_G * _Mask1_Gchannel_ColorAmountA;
				float4 lerpResult160 = lerp(lerpResult145, _Mask1_G_Color, clampResult296);

				float clampResult297 = clamp((tex2DNode143.b * tex2D_mask1_B.a * _Mask1_Bchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask1_B_Color = tex2D_mask1_B * _Mask1_Bchannel_ColorAmountA;
				float4 lerpResult161 = lerp(lerpResult160, _Mask1_B_Color, clampResult297);

				float clampResult2971 = clamp((tex2DNode143.a * tex2D_mask1_A.a * _Mask1_Achannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask1_A_Color = tex2D_mask1_A * _Mask1_Achannel_ColorAmountA;
				float4 lerpResult1611 = lerp(lerpResult161, _Mask1_A_Color, clampResult2971);
				//mask2
				float2 uv_MakeUpMask2_RGB = uv.xy * _MakeUpMask2_RGB_ST.xy + _MakeUpMask2_RGB_ST.zw;
				float4 tex2DNode144 = SAMPLE_TEXTURE2D(_MakeUpMask2_RGB, sampler_MakeUpMask2_RGB, uv_MakeUpMask2_RGB);

				float clampResult298 = clamp((tex2DNode144.r * tex2D_mask2_R.a * _Mask2_Rchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask2_R_Color = tex2D_mask2_R * _Mask2_Rchannel_ColorAmountA;
				float4 lerpResult162 = lerp(lerpResult1611, _Mask2_Rchannel_ColorAmountA, clampResult298);

				float clampResult299 = clamp((tex2DNode144.g * tex2D_mask2_G.a * _Mask2_Gchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask2_G_Color = tex2D_mask2_G * _Mask2_Gchannel_ColorAmountA;
				float4 lerpResult163 = lerp(lerpResult162, _Mask2_Gchannel_ColorAmountA, clampResult299);

				float clampResult300 = clamp((tex2DNode144.b * tex2D_mask2_B.a * _Mask2_Bchannel_ColorAmountA.a), 0.0, 1.0);
				float4 _Mask2_B_Color = tex2D_mask2_B * _Mask2_Bchannel_ColorAmountA;
				float4 lerpResult164 = lerp(lerpResult163, _Mask2_Bchannel_ColorAmountA, clampResult300);

				albedoAlpha.rgb = half3(lerpResult164.r, lerpResult164.g, lerpResult164.b);

				return albedoAlpha;
			}
			
			half4 frag (Varyings input) : SV_Target
			{
				// clip cloth mask
				half v_ClothMask1 = _ClothMask1.Sample(sampler_ClothMask1, input.uv.xy).r;
				clip(v_ClothMask1 - 0.5);
				half v_ClothMask2 = _ClothMask2.Sample(sampler_ClothMask2, input.uv.xy).r;
				clip(v_ClothMask2 - 0.5);
				half v_ClothMask3 = _ClothMask3.Sample(sampler_ClothMask3, input.uv.xy).r;
				clip(v_ClothMask3 - 0.5);
				half2 uv1 = input.uv.xy;
				half2 uv2 = input.uv.zw;
				//向量
				float3 normalDir = normalize(input.normalWS);
				//float3 lightDir = normalize(_MainLightPosition.xyz);
				float3 viewDir = normalize(_WorldSpaceCameraPos - input.positionWS);
				//Base贴图
				//half4 base_map = SAMPLE_TEXTURE2D(_BaseMap,sampler_BaseMap,uv1);
				half4 base_map = GetColor(uv1);




				half3 base_color = base_map.rgb; // 亮部的颜色
				half base_mask = base_map.a; //用来区分皮肤和非皮肤区域
				//SSS贴图
				half4 sss_map = SAMPLE_TEXTURE2D(_SSSMap,sampler_SSSMap, uv1);
				//half3 sss_color = sss_map.rgb * _BaseColor; //暗部的颜色
				//half sss_alpha = sss_map.a; //边缘光的强度控制
				half3 sss_color = base_color; //暗部的颜色
				half sss_alpha = base_map.a; //边缘光的强度控制
				//ILM贴图
				half4 ilm_map = SAMPLE_TEXTURE2D(_ILMMap,sampler_ILMMap, uv1);
				float spec_intensity = ilm_map.r; //控制高光强度
				float diffuse_control = ilm_map.g * 2.0 - 1.0; //控制光照的偏移
				float spec_size = ilm_map.b; //控制高光形状大小
				float inner_line = ilm_map.a; //内描线
				//顶点色
				float ao = input.vertexColor.r;
				Light mainLight = GetMainLight(input.shadowCoord,input.positionWS,float4(1.0,1.0,1.0,1.0));
				float3 lightDir = mainLight.direction;
				float shadow = mainLight.shadowAttenuation;
				//float shadow = MainLightRealtimeShadow(input.shadowCoord);
				float atten = lerp(1 , shadow, input.vertexColor.g);
			
				//漫反射
				half NdotL = dot(normalDir, lightDir);
				half half_lambert = (NdotL + 1.0) * 0.5;
				half labmbert_term = half_lambert * ao * atten + diffuse_control;
				half toon_diffuse = saturate((labmbert_term - _ToonThesHold) * _ToonHardness);
				//多光源
				#ifdef _ADDITIONAL_LIGHTS
					uint pixelLightCount = GetAdditionalLightsCount();
					for(uint lightIndex = 0; lightIndex < pixelLightCount; ++lightIndex)
					{
						Light light = GetAdditionalLight(lightIndex,input.positionWS,float4(1.0,1.0,1.0,1.0));
						half NdotL_add = dot(normalDir, light.direction);
						half half_lambert_add = (NdotL_add + 1.0) * 0.5;
						float atten_add = lerp(1 , light.shadowAttenuation * light.distanceAttenuation , input.vertexColor.g);
						half labmbert_term_add = half_lambert_add * ao * atten_add + diffuse_control;
						toon_diffuse += saturate((labmbert_term_add * light.color - _ToonThesHold) * _ToonHardness);
					}
				#endif

				half3 final_diffuse = lerp(sss_color, base_color,toon_diffuse);
				//高光
				float NdotV = (dot(normalDir, viewDir) + 1.0) * 0.5;
				float spec_term = NdotV * ao + diffuse_control;
				spec_term = half_lambert * 0.9 + spec_term * 0.1;
				half toon_spec = saturate((spec_term - (1.0 - spec_size * _SpecSize)) * 500);
				half3 spec_color = (_SpecColor.rgb + base_color) * 0.5;
				half3 final_spec = toon_spec * spec_color * spec_intensity;
				//描线
				half3 inner_line_color = lerp(base_color * 0.2,float3(1.0,1.0,1.0),inner_line);
				half3 detail_color = SAMPLE_TEXTURE2D(_DetailMap,sampler_DetailMap, uv2);//第二套UV Detail细节图
				detail_color = lerp(base_color * 0.2, float3(1.0, 1.0, 1.0), detail_color);
				half3 final_line = inner_line_color * inner_line_color * detail_color;
				//补光、边缘
				float3 lightDir_rim = normalize(mul((float3x3)unity_MatrixInvV,_RimLightDir.xyz));
				half NdotL_rim = (dot(normalDir, lightDir_rim)+ 1.0) * 0.5;
				half rimlight_term = NdotL_rim + diffuse_control;
				half toon_rim = saturate((rimlight_term - _ToonThesHold) * 20);
				half3 rim_color = (_RimLightColor.rgb + base_color) * 0.5 * sss_alpha;
				half3 final_rimlight = toon_rim * rim_color * base_mask * toon_diffuse * _RimLightColor.a;
				
				half3 final_color = (final_diffuse + final_spec + final_rimlight) * final_line;
				final_color = sqrt(max(exp2(log2(max(final_color, 0.0)) * 2.2), 0.0));
				return float4(final_color,1.0);
			}
			ENDHLSL
		}
		Pass
		{
			Cull Front
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#include "UnityCG.cginc"
			#include "AutoLight.cginc"


			struct appdata
			{
				float4 vertex : POSITION;
				float2 texcoord0 : TEXCOORD0;
				float3 normal : NORMAL;
				float4 color : COLOR;
			};

			struct v2f
			{
				float4 pos : SV_POSITION;
				float2 uv : TEXCOORD0;
				float4 vertex_color : TEXCOORD3;
			};

			sampler2D _BaseMap;
			sampler2D _SSSMap;
			sampler2D _ILMMap;
			float _OutlineWidth;
			float _OutlineZbias;
			float4 _OutlineColor;
			sampler2D _ClothMask1;
			sampler2D _ClothMask2;
			sampler2D _ClothMask3;
			
			v2f vert (appdata v)
			{
				v2f o;
				float3 pos_view = UnityObjectToViewPos(v.vertex);
				float3 normal_world = UnityObjectToWorldNormal(v.normal);
				float3 outline_dir = normalize(mul((float3x3)UNITY_MATRIX_V, normal_world));
				outline_dir.z = _OutlineZbias * (1.0 - v.color.b);
				pos_view += outline_dir * _OutlineWidth * 0.001 * v.color.a;
				o.pos = mul(UNITY_MATRIX_P, float4(pos_view, 1.0));
				o.uv = v.texcoord0;
				o.vertex_color = v.color;
				return o;
			}
			
			half4 frag(v2f i) : SV_Target
			{
				half v_ClothMask1 = tex2D(_ClothMask1, i.uv.xy).r;//_ClothMask1.Sample(sampler_ClothMask1, input.uv.xy).r;
				clip(v_ClothMask1 - 0.5);
				half v_ClothMask2 = tex2D(_ClothMask2, i.uv.xy).r;
				clip(v_ClothMask2 - 0.5);
				half v_ClothMask3 = tex2D(_ClothMask3, i.uv.xy).r;
				clip(v_ClothMask3 - 0.5);
				float3 basecolor = tex2D(_BaseMap, i.uv.xy).xyz;
				half maxComponent = max(max(basecolor.r, basecolor.g), basecolor.b) - 0.004;
				half3 saturatedColor = step(maxComponent.rrr, basecolor) * basecolor;
				saturatedColor = lerp(basecolor.rgb, saturatedColor, 0.6);
				half3 outlineColor = 0.8 * saturatedColor * basecolor * _OutlineColor.xyz;
				return float4(outlineColor, 1.0);
			}
			ENDCG
		}
		Pass
        {
            Name "ShadowCaster"
            Tags{"LightMode" = "ShadowCaster"}

            ZWrite On
            ZTest LEqual
            ColorMask 0
            Cull[_Cull]

            HLSLPROGRAM
            #pragma exclude_renderers gles gles3 glcore
            #pragma target 4.5

            // -------------------------------------
            // Material Keywords
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

            //--------------------------------------
            // GPU Instancing
            #pragma multi_compile_instancing
            #pragma multi_compile _ DOTS_INSTANCING_ON

            // -------------------------------------
            // Universal Pipeline keywords

            // This is used during shadow map generation to differentiate between directional and punctual light shadows, as they use different formulas to apply Normal Bias
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW

            #pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment

            #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
            ENDHLSL
        }
		Pass
        {
            Name "DepthOnly"
            Tags{"LightMode" = "DepthOnly"}

            ZWrite On
            ColorMask 0
            Cull[_Cull]

            HLSLPROGRAM
            #pragma exclude_renderers gles gles3 glcore
            #pragma target 4.5

            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment

            // -------------------------------------
            // Material Keywords
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

            //--------------------------------------
            // GPU Instancing
            #pragma multi_compile_instancing
            #pragma multi_compile _ DOTS_INSTANCING_ON

            #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
		    #include "Packages/com.unity.render-pipelines.universal/Shaders/LitMetaPass.hlsl"
            ENDHLSL
        }

	//	Pass
	//	{
	//		Name "ForwardLit"
	//		Tags{"LightMode" = "UniversalForward"}

	//		Stencil {
	//			Ref[_Stencil]
	//			ReadMask[_ReadMask]
	//			WriteMask[_WriteMask]
	//			Comp[_StencilComp]
	//			Pass[_StencilOp]
	//			Fail[_StencilFail]
	//			ZFail[_StencilZFail]
	//		}

	//		ZWrite On
	//		Cull Back

	//		HLSLPROGRAM
	//		// Required to compile gles 2.0 with standard SRP library
	//		#pragma prefer_hlslcc gles
	//		#pragma exclude_renderers d3d11_9x
	//		#pragma target 2.0

	//		// -------------------------------------
	//		// Material Keywords
	//		#define _SPECULAR_SETUP
	//		#pragma shader_feature_local _NORMALMAP
	//		#pragma shader_feature_local_fragment _NORMALMAPDIFFUSE
	//		#pragma shader_feature_local _DISTANCEFADE 					// not per fragment
	//		#pragma shader_feature_local_fragment _RIMLIGHTING
	//		#pragma shader_feature_local_fragment _BACKSCATTER

	//		#pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
	//		#pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF
	//		#pragma shader_feature_local _RECEIVE_SHADOWS_OFF

	//		// -------------------------------------
	//		// Universal Pipeline keywords
	//		#pragma multi_compile _ _MAIN_LIGHT_SHADOWS
	//		#pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
	//		#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
	//		#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
	//		#pragma multi_compile_fragment _ _SHADOWS_SOFT
	//		#pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
	//		#pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
	//		#pragma multi_compile _ SHADOWS_SHADOWMASK

	//		// -------------------------------------
	//		// Unity defined keywords
	//		#pragma multi_compile _ DIRLIGHTMAP_COMBINED
	//		#pragma multi_compile _ LIGHTMAP_ON
	//		#pragma multi_compile_fog

	//		//--------------------------------------
	//		// GPU Instancing
	//		#pragma multi_compile_instancing
	//		// #pragma multi_compile _ DOTS_INSTANCING_ON // needs shader target 4.5

	//	//  Include base inputs and all other needed "base" includes
	//		#include "Includes/Lux URP Skin Inputs Custom.hlsl"

	//		#pragma vertex LitPassVertex
	//		#pragma fragment LitPassFragment

	//	//--------------------------------------
	//	//  Vertex shader

	//		VertexOutput LitPassVertex(VertexInput input)
	//		{
	//			VertexOutput output = (VertexOutput)0;
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_TRANSFER_INSTANCE_ID(input, output);
	//			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

	//		//  Set distance fade value
	//			#if defined(_DISTANCEFADE)
	//				float3 worldInstancePos = UNITY_MATRIX_M._m03_m13_m23;
	//				float3 diff = (_WorldSpaceCameraPos - worldInstancePos);
	//				float dist = dot(diff, diff);
	//				output.fade = saturate((_DistanceFade.x - dist) * _DistanceFade.y);
	//			#else
	//				output.fade = 1.0h;
	//			#endif

	//			VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
	//			VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);

	//			float3 viewDirWS = GetCameraPositionWS() - vertexInput.positionWS;
	//			half3 vertexLight = VertexLighting(vertexInput.positionWS, normalInput.normalWS);
	//			half fogFactor = ComputeFogFactor(vertexInput.positionCS.z);

	//			output.uv.xy = input.texcoord;

	//			output.normalWS = normalInput.normalWS; //NormalizeNormalPerVertex(normalInput.normalWS);
	//			output.viewDirWS = viewDirWS;

	//			#ifdef _NORMALMAP
	//				float sign = input.tangentOS.w * GetOddNegativeScale();
	//				output.tangentWS = float4(normalInput.tangentWS.xyz, sign);
	//			#endif

	//			OUTPUT_LIGHTMAP_UV(input.lightmapUV, unity_LightmapST, output.lightmapUV);
	//			OUTPUT_SH(output.normalWS.xyz, output.vertexSH);

	//			output.fogFactorAndVertexLight = half4(fogFactor, vertexLight);

	//			#if defined(REQUIRES_WORLD_SPACE_POS_INTERPOLATOR)
	//				output.positionWS = vertexInput.positionWS;
	//			#endif

	//			#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
	//			//  tweak the sampling position
	//				vertexInput.positionWS += output.normalWS.xyz * _SkinShadowSamplingBias;
	//				output.shadowCoord = GetShadowCoord(vertexInput);
	//			#endif
	//			output.positionCS = vertexInput.positionCS;

	//			return output;
	//		}

	//	//--------------------------------------
	//	//  Fragment shader and functions

	//		inline void InitializeSkinLitSurfaceData(float2 uv, half fade, out SurfaceDescription outSurfaceData)
	//		{
	//			half4 albedoAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)) * _BaseColor;

	//			//--------------------------------------------------------
	//			float2 uv_MakeUpMask1_RGB = uv.xy * _MakeUpMask1_RGB_ST.xy + _MakeUpMask1_RGB_ST.zw;
	//			float4 tex2DNode143 = SAMPLE_TEXTURE2D(_MakeUpMask1_RGB, sampler_MakeUpMask1_RGB, uv_MakeUpMask1_RGB);


	//			float2 uv_Mask1_Rchannel_TextureAmountA = uv.xy * _Mask1_Rchannel_TextureAmountA_ST.xy + _Mask1_Rchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask1_R = SAMPLE_TEXTURE2D(_Mask1_Rchannel_TextureAmountA, sampler_Mask1_Rchannel_TextureAmountA, uv_Mask1_Rchannel_TextureAmountA);

	//			float2 uv_Mask1_Gchannel_TextureAmountA = uv.xy * _Mask1_Gchannel_TextureAmountA_ST.xy + _Mask1_Gchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask1_G = SAMPLE_TEXTURE2D(_Mask1_Gchannel_TextureAmountA, sampler_Mask1_Gchannel_TextureAmountA, uv_Mask1_Gchannel_TextureAmountA);

	//			float2 uv_Mask1_Bchannel_TextureAmountA = uv.xy * _Mask1_Bchannel_TextureAmountA_ST.xy + _Mask1_Bchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask1_B = SAMPLE_TEXTURE2D(_Mask1_Bchannel_TextureAmountA, sampler_Mask1_Bchannel_TextureAmountA, uv_Mask1_Bchannel_TextureAmountA);

	//			float2 uv_Mask1_Achannel_TextureAmountA = uv.xy * _Mask1_Achannel_TextureAmountA_ST.xy + _Mask1_Achannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask1_A = SAMPLE_TEXTURE2D(_Mask1_Bchannel_TextureAmountA, sampler_Mask1_Bchannel_TextureAmountA, uv_Mask1_Achannel_TextureAmountA);

	//			float2 uv_Mask2_Rchannel_TextureAmountA = uv.xy * _Mask2_Rchannel_TextureAmountA_ST.xy + _Mask2_Rchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask2_R = SAMPLE_TEXTURE2D(_Mask2_Rchannel_TextureAmountA, sampler_Mask2_Rchannel_TextureAmountA, uv_Mask2_Rchannel_TextureAmountA);

	//			float2 uv_Mask2_Gchannel_TextureAmountA = uv.xy * _Mask2_Gchannel_TextureAmountA_ST.xy + _Mask2_Gchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask2_G = SAMPLE_TEXTURE2D(_Mask2_Gchannel_TextureAmountA, sampler_Mask2_Gchannel_TextureAmountA, uv_Mask2_Gchannel_TextureAmountA);

	//			float2 uv_Mask2_Bchannel_TextureAmountA = uv.xy * _Mask2_Bchannel_TextureAmountA_ST.xy + _Mask2_Bchannel_TextureAmountA_ST.zw;
	//			float4 tex2D_mask2_B = SAMPLE_TEXTURE2D(_Mask2_Bchannel_TextureAmountA, sampler_Mask2_Bchannel_TextureAmountA, uv_Mask2_Bchannel_TextureAmountA);

	//			float clampResult295 = clamp((tex2DNode143.r * tex2D_mask1_R.a * _Mask1_Rchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask1_R_Color = tex2D_mask1_R * _Mask1_Rchannel_ColorAmountA;
	//			float4 lerpResult145 = lerp(albedoAlpha, _Mask1_R_Color, clampResult295);

	//			float clampResult296 = clamp((tex2DNode143.g * tex2D_mask1_G.a * _Mask1_Gchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask1_G_Color = tex2D_mask1_G * _Mask1_Gchannel_ColorAmountA;
	//			float4 lerpResult160 = lerp(lerpResult145, _Mask1_G_Color, clampResult296);

	//			float clampResult297 = clamp((tex2DNode143.b * tex2D_mask1_B.a * _Mask1_Bchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask1_B_Color = tex2D_mask1_B * _Mask1_Bchannel_ColorAmountA;
	//			float4 lerpResult161 = lerp(lerpResult160, _Mask1_B_Color, clampResult297);

	//			float clampResult2971 = clamp((tex2DNode143.a * tex2D_mask1_A.a * _Mask1_Achannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask1_A_Color = tex2D_mask1_A * _Mask1_Achannel_ColorAmountA;
	//			float4 lerpResult1611 = lerp(lerpResult161, _Mask1_A_Color, clampResult2971);
	//			//mask2
	//			float2 uv_MakeUpMask2_RGB = uv.xy * _MakeUpMask2_RGB_ST.xy + _MakeUpMask2_RGB_ST.zw;
	//			float4 tex2DNode144 = SAMPLE_TEXTURE2D(_MakeUpMask2_RGB, sampler_MakeUpMask2_RGB, uv_MakeUpMask2_RGB);

	//			float clampResult298 = clamp((tex2DNode144.r * tex2D_mask2_R.a * _Mask2_Rchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask2_R_Color = tex2D_mask2_R * _Mask2_Rchannel_ColorAmountA;
	//			float4 lerpResult162 = lerp(lerpResult1611, _Mask2_Rchannel_ColorAmountA, clampResult298);

	//			float clampResult299 = clamp((tex2DNode144.g * tex2D_mask2_G.a * _Mask2_Gchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask2_G_Color = tex2D_mask2_G * _Mask2_Gchannel_ColorAmountA;
	//			float4 lerpResult163 = lerp(lerpResult162, _Mask2_Gchannel_ColorAmountA, clampResult299);

	//			float clampResult300 = clamp((tex2DNode144.b * tex2D_mask2_B.a * _Mask2_Bchannel_ColorAmountA.a), 0.0, 1.0);
	//			float4 _Mask2_B_Color = tex2D_mask2_B * _Mask2_Bchannel_ColorAmountA;
	//			float4 lerpResult164 = lerp(lerpResult163, _Mask2_Bchannel_ColorAmountA, clampResult300);

	//			albedoAlpha.rgb = half3(lerpResult164.r, lerpResult164.g, lerpResult164.b);
	//			//--------------------------------

	//			outSurfaceData.alpha = 1;

	//			outSurfaceData.albedo = albedoAlpha.rgb;
	//			outSurfaceData.metallic = 0;
	//			outSurfaceData.specular = _SpecularColor.rgb;

	//		//  Normal Map
	//			#if defined (_NORMALMAP)
	//				outSurfaceData.normalTS = SampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale);
	//				#if defined(_NORMALMAPDIFFUSE)
	//					half4 sampleNormalDiffuse = SAMPLE_TEXTURE2D_BIAS(_BumpMap, sampler_BumpMap, uv, _Bias);
	//				//  Do not manually unpack the normal map as it might use RGB.
	//					outSurfaceData.diffuseNormalTS = UnpackNormal(sampleNormalDiffuse);
	//				#else
	//					outSurfaceData.diffuseNormalTS = half3(0,0,1);
	//				#endif
	//		    #else
	//				outSurfaceData.normalTS = half3(0,0,1);
	//				outSurfaceData.diffuseNormalTS = half3(0,0,1);
	//			#endif

	//			half4 SSSAOSample = SAMPLE_TEXTURE2D(_SSSAOMap, sampler_SSSAOMap, uv);
	//			outSurfaceData.translucency = SSSAOSample.g;
	//			outSurfaceData.skinMask = SSSAOSample.r;
	//			outSurfaceData.occlusion = lerp(1.0h, SSSAOSample.a, _OcclusionStrength);
	//			outSurfaceData.curvature = SSSAOSample.b;

	//			outSurfaceData.smoothness = albedoAlpha.a * _Smoothness;
	//			outSurfaceData.emission = SAMPLE_TEXTURE2D(_EmissionMap, sampler_EmissionMap, uv).rgb * _EmissionColor.rgb;
	//		}

	//		void InitializeInputData(VertexOutput input, half3 normalTS, half3 diffuseNormalTS, out InputData inputData
	//		    #ifdef _NORMALMAP
	//				, inout float3 bitangent
	//			#endif
	//			, inout half3 diffuseNormalWS
	//			)
	//		{
	//			inputData = (InputData)0;
	//			#if defined(REQUIRES_WORLD_SPACE_POS_INTERPOLATOR)
	//				inputData.positionWS = input.positionWS;
	//			#endif
	//			half3 viewDirWS = SafeNormalize(input.viewDirWS);

	//			#ifdef _NORMALMAP
	//				float sgn = input.tangentWS.w;      // should be either +1 or -1
	//				bitangent = sgn * cross(input.normalWS.xyz, input.tangentWS.xyz);
	//				half3x3 ToW = half3x3(input.tangentWS.xyz, bitangent, input.normalWS.xyz);
	//				inputData.normalWS = TransformTangentToWorld(normalTS, ToW);
	//				inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS);
	//				#ifdef _NORMALMAPDIFFUSE
	//					diffuseNormalWS = TransformTangentToWorld(diffuseNormalTS, ToW);
	//					diffuseNormalWS = NormalizeNormalPerPixel(diffuseNormalWS);
	//				#else
	//				//  Here we let the user decide to use the per vertex or the specular normal.
	//					diffuseNormalWS = (_VertexNormal) ? NormalizeNormalPerPixel(input.normalWS.xyz) : inputData.normalWS;
	//				#endif
	//			#else
	//				inputData.normalWS = NormalizeNormalPerPixel(input.normalWS);
	//				diffuseNormalWS = inputData.normalWS;
	//			#endif

	//			inputData.viewDirectionWS = viewDirWS;

	//			#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
	//				inputData.shadowCoord = input.shadowCoord;
	//			#elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
	//				inputData.shadowCoord = TransformWorldToShadowCoord(inputData.positionWS + input.normalWS * _SkinShadowSamplingBias);
	//			#else
	//				inputData.shadowCoord = float4(0, 0, 0, 0);
	//			#endif

	//			inputData.fogCoord = input.fogFactorAndVertexLight.x;
	//			inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
	//			inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.vertexSH, diffuseNormalWS); //inputData.normalWS);

	//			//inputData.normalizedScreenSpaceUV = input.positionCS.xy;
	//			inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);
	//		}

	//		half4 LitPassFragment(VertexOutput input) : SV_Target
	//		{
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

	//			// clip cloth mask
	//			half v_ClothMask1 = _ClothMask1.Sample(sampler_ClothMask1, input.uv.xy).r;
	//			clip(v_ClothMask1 - 0.5);
	//			half v_ClothMask2 = _ClothMask2.Sample(sampler_ClothMask1, input.uv.xy).r;
	//			clip(v_ClothMask2 - 0.5);
	//			half v_ClothMask3 = _ClothMask3.Sample(sampler_ClothMask1, input.uv.xy).r;
	//			clip(v_ClothMask3 - 0.5);

	//		//  Get the surface description
	//			SurfaceDescription surfaceData;
	//			InitializeSkinLitSurfaceData(input.uv.xy, input.fade, surfaceData);

	//		//  Prepare surface data (like bring normal into world space and get missing inputs like gi
	//			half3 diffuseNormalWS;
	//			InputData inputData;
	//			#ifdef _NORMALMAP
	//				float3 bitangent;
	//			#endif
	//			InitializeInputData(input, surfaceData.normalTS, surfaceData.diffuseNormalTS, inputData
	//				#ifdef _NORMALMAP
	//					, bitangent
	//				#endif
	//				, diffuseNormalWS
	//			);

	//			#if defined(_RIMLIGHTING)
	//				half rim = saturate(1.0h - saturate(dot(inputData.normalWS, inputData.viewDirectionWS)));
	//				half power = _RimPower;
	//				UNITY_BRANCH if (_RimFrequency > 0) {
	//					half perPosition = lerp(0.0h, 1.0h, dot(1.0h, frac(UNITY_MATRIX_M._m03_m13_m23) * 2.0h - 1.0h) * _RimPerPositionFrequency) * 3.1416h;
	//					power = lerp(power, _RimMinPower, (1.0h + sin(_Time.y * _RimFrequency + perPosition)) * 0.5h);
	//				}
	//				surfaceData.emission += pow(rim, power) * _RimColor.rgb * _RimColor.a;
	//			#endif

	//		//  Apply lighting
	//			half4 color = LuxLWRPSkinFragmentPBR(
	//				inputData,
	//				surfaceData.albedo,
	//				surfaceData.metallic,
	//				surfaceData.specular,
	//				surfaceData.smoothness,
	//				surfaceData.occlusion,
	//				surfaceData.emission,
	//				surfaceData.alpha,
	//			//  Subsurface Scattering
	//				half4(_TranslucencyStrength * surfaceData.translucency, _TranslucencyPower, _ShadowStrength, _Distortion),
	//			//  AmbientReflection Strength
	//				_AmbientReflectionStrength,
	//			//  Diffuse Normal
	//				// #if defined(_NORMALMAP) && defined(_NORMALMAPDIFFUSE)
	//				//     NormalizeNormalPerPixel( TransformTangentToWorld(surfaceData.diffuseNormalTS, half3x3(input.tangentWS.xyz, bitangent, input.normalWS.xyz)) )
	//				// #else
	//				//     input.normalWS
	//				// #endif
	//				diffuseNormalWS,
	//				_SubsurfaceColor.rgb,
	//				(_SampleCurvature) ? surfaceData.curvature * _Curvature : lerp(surfaceData.translucency, 1, _Curvature),
	//			//  Lerp lighting towards standard according the distance fade
	//				surfaceData.skinMask * input.fade,
	//				_MaskByShadowStrength,
	//				_Backscatter
	//				);

	//		//  Add fog
	//			color.rgb = MixFog(color.rgb, inputData.fogCoord);

	//			return color;
	//		}

	//		ENDHLSL
	//	}

	//	//  Shadows -----------------------------------------------------

	//	Pass
	//	{
	//		Name "ShadowCaster"
	//		Tags{"LightMode" = "ShadowCaster"}

	//		ZWrite On
	//		ZTest LEqual
	//		ColorMask 0
	//		Cull Back

	//		HLSLPROGRAM
	//		// Required to compile gles 2.0 with standard srp library
	//		#pragma prefer_hlslcc gles
	//		#pragma exclude_renderers d3d11_9x
	//		#pragma target 2.0

	//		// -------------------------------------
	//		// Material Keywords


	//		//--------------------------------------
	//		// GPU Instancing
	//		#pragma multi_compile_instancing

	//		#pragma vertex ShadowPassVertex
	//		#pragma fragment ShadowPassFragment

	//	//  Include base inputs and all other needed "base" includes
	//		#include "Includes/Lux URP Skin Inputs Custom.hlsl"
	//		#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

	//	//  Shadow caster specific input
	//		float3 _LightDirection;

	//		VertexOutput ShadowPassVertex(VertexInput input)
	//		{
	//			VertexOutput output = (VertexOutput)0;
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_TRANSFER_INSTANCE_ID(input, output);

	//			float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
	//			float3 normalWS = TransformObjectToWorldDir(input.normalOS);

	//			output.positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS * _SkinShadowBias, _LightDirection));
	//			#if UNITY_REVERSED_Z
	//				output.positionCS.z = min(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
	//			#else
	//				output.positionCS.z = max(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
	//			#endif
	//			return output;
	//		}

	//		half4 ShadowPassFragment(VertexOutput input) : SV_TARGET
	//		{
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
	//			return 0;
	//		}
	//		ENDHLSL
	//	}


	////  Depth -----------------------------------------------------

	//	Pass
	//	{
	//		Tags{"LightMode" = "DepthOnly"}

	//		ZWrite On
	//		ColorMask 0
	//		Cull Back

	//		HLSLPROGRAM
	//		// Required to compile gles 2.0 with standard srp library
	//		#pragma prefer_hlslcc gles
	//		#pragma exclude_renderers d3d11_9x
	//		#pragma target 2.0

	//		#pragma vertex DepthOnlyVertex
	//		#pragma fragment DepthOnlyFragment

	//		// -------------------------------------
	//		// Material Keywords

	//		//--------------------------------------
	//		// GPU Instancing
	//		#pragma multi_compile_instancing

	//		#define DEPTHONLYPASS
	//		#include "Includes/Lux URP Skin Inputs Custom.hlsl"

	//		VertexOutput DepthOnlyVertex(VertexInput input)
	//		{
	//			VertexOutput output = (VertexOutput)0;
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_TRANSFER_INSTANCE_ID(input, output);
	//			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

	//			output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
	//			return output;
	//		}

	//		half4 DepthOnlyFragment(VertexOutput input) : SV_TARGET
	//		{
	//			UNITY_SETUP_INSTANCE_ID(input);
	//			UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
	//			return 0;
	//		}

	//		ENDHLSL
	//	}

	////  Depth Normals --------------------------------------------
	//	Pass
	//	{
	//		Name "DepthNormals"
	//		Tags{"LightMode" = "DepthNormals"}

	//		ZWrite On
	//		Cull Back

	//		HLSLPROGRAM
	//		// Required to compile gles 2.0 with standard SRP library
	//		#pragma prefer_hlslcc gles
	//		#pragma exclude_renderers d3d11_9x
	//		#pragma target 2.0

	//		#pragma vertex DepthNormalsVertex
	//		#pragma fragment DepthNormalsFragment

	//		// -------------------------------------
	//		// Material Keywords
	//		#pragma shader_feature_local _NORMALMAP

	//		//--------------------------------------
	//		// GPU Instancing
	//		#pragma multi_compile_instancing
	//		// #pragma multi_compile _ DOTS_INSTANCING_ON // needs shader target 4.5

	//		//#include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
	//		#include "Includes/Lux URP Skin Inputs Custom.hlsl"
	//		#include "Packages/com.unity.render-pipelines.universal/Shaders/DepthNormalsPass.hlsl"
	//		ENDHLSL
	//	}

	////  Meta -----------------------------------------------------

	//	Pass
	//	{
	//		Tags{"LightMode" = "Meta"}

	//		Cull Off

	//		HLSLPROGRAM
	//		// Required to compile gles 2.0 with standard srp library
	//		#pragma prefer_hlslcc gles

	//		#pragma vertex UniversalVertexMeta
	//		#pragma fragment UniversalFragmentMeta

	//		#define _SPECULAR_SETUP

	//	//  First include all our custom stuff
	//		#include "Includes/Lux URP Skin Inputs Custom.hlsl"

	//	//--------------------------------------
	//	//  Fragment shader and functions

	//		inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
	//		{
	//			half4 albedoAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap));
	//			outSurfaceData.alpha = 1;
	//			outSurfaceData.albedo = albedoAlpha.rgb;
	//			outSurfaceData.metallic = 0;
	//			outSurfaceData.specular = _SpecularColor.rgb;
	//			outSurfaceData.smoothness = _Smoothness;
	//			outSurfaceData.normalTS = half3(0,0,1);
	//			outSurfaceData.occlusion = 1;
	//			outSurfaceData.emission = 0;

	//			outSurfaceData.clearCoatMask = 0;
	//			outSurfaceData.clearCoatSmoothness = 0;
	//		}

	//	//  Finally include the meta pass related stuff  
	//		#include "Packages/com.unity.render-pipelines.universal/Shaders/LitMetaPass.hlsl"

	//		ENDHLSL
	//	}

	//  End Passes -----------------------------------------------------

	}
	CustomEditor "LuxURPCustomSkinShaderGUI"
	FallBack "Hidden/InternalErrorShader"
 }