metaverse_artist/Player/Shader/New_Skin.shader

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

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

		[ToggleOff]_Receive_Shadows ("Receive Shadows", Float) = 1.0
		_BaseColor ("Color", Color) = (1,1,1,1)
		_BaseMap ("BaseTex", 2D) = "white" { }
		_ClothMask1("Cloth Mask1", 2D) = "white" {}
		_ClothMask2("Cloth Mask2", 2D) = "white" {}
		_ClothMask3("Cloth Mask3", 2D) = "white" {}
		_BumpMap ("NormalMap", 2D) = "bump" { }
		_MetalSmoothTex ("R粗糙度,G金属度,B=AO", 2D) = "white" { }
		_SSSMap ("R=SSS,G=自发光,B=透明", 2D) = "black" { }
		_BloomTex ("Bloom MaskTex", 2D) = "black" { }
		[Header(Rough Metal Control)] _Metalness ("金属度", Range(0, 1)) = 1
		_Roughness ("粗糙度", Range(0, 1)) = 1
		[Header(Light Control)] _DirLightColor ("平行光颜色", Color) = (1,1,1,0)
		_DirLightExposure ("平行光亮度", Range(0, 10)) = 0.8
		_EnvExposure ("环境光强度", Range(0, 10)) = 0.96
		_SHExposure ("SH亮度", Range(0, 10)) = 0.53
		[Header(SSS Control)] _SkinSSSfresnelMask ("皮肤菲尼尔", Range(0, 1)) = 0.128
		_SkinSSSTransmission ("SSS强度", Range(0, 1)) = 0.866
		_SkinSSSScatterColor ("SSS颜色", Color) = (1.0,0.3161765,0.3161765,0)
		[Header(Shadow Control)] _ShadowDarkness ("阴影深浅", Range(0, 1)) = 0
		_ShadowCol ("阴影颜色", Color) = (0,0,0,0)
		_EmissionCol ("自发光颜色", Color) = (0.448,0.591,0.662,0)
		_EmissionExposure ("自发光亮度", Float) = 1
		[Header(Advanced Control (Ask TA About This))]
		_PunctualLightSpecularExposure ("高光亮度", Range(0, 10)) = 1
		_PointLightExposure("点光亮度", Range(0, 10)) = 1
		_CosMin("暗部曝光", Range(0.01, 0.95)) = 0.01
		_envBDRFFactor("高光色泽度", Range(-1, 1)) = 0.58
		[Header(PostProcessing Control)] _BloomIntensity ("Bloom 强度", Float) = 1
		_DarkCornerColor("DarkCornerColor", Vector) = (0,0,0,0)

		[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" {}
		_Mask1_Achannel_TextureAmountA("Mask1_Achannel_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

	}

	Category{
		CGINCLUDE
// Upgrade NOTE: excluded shader from OpenGL ES 2.0 because it uses non-square matrices
			#pragma exclude_renderers gles

			#include "UnityCG.cginc"
			#include "UnityPBSLighting.cginc"

			#include "AutoLight.cginc"

			sampler2D _BaseMap, _BumpMap, _MetalSmoothTex, _EmissiveTex;

			float4 _DirLightColor, _SkinSSSScatterColor, _MainTex_ST,_BaseMap_ST;

			float3 _EmissionCol, _ShadowCol;

			half4 _BaseColor;

			float _Metalness, _Roughness, _DirLightExposure, _EnvExposure, _SHExposure, _SkinSSSfresnelMask, _SkinSSSTransmission, _ShadowDarkness, _EmissionExposure, _PointLightExposure, _PunctualLightSpecularExposure, _CosMin;
			fixed _envBDRFFactor;
			uniform sampler2D _EnvironmentTex, _SGameShadowTexture;
			uniform float4x4 _SGameShadowMatrix, _SGameMV, _envSHR, _envSHG, _envSHB, _envRot;

			//uniform float4 _SGameShadowParams, _PointLightPosAndRange, _PointLightColorAndAtten;
			uniform float _Global_BloomThreshold;
			uniform half4 _HeroShowOverallExposureColor;
			uniform half3 _DarkCornerColor;
			uniform half _BloomIntensity;

			sampler2D _MakeUpMask1_RGB;
			sampler2D _MakeUpMask2_RGB;
			sampler2D _Mask1_Rchannel_TextureAmountA;
			sampler2D _Mask1_Gchannel_TextureAmountA;
			sampler2D _Mask1_Bchannel_TextureAmountA;
			sampler2D _Mask1_Achannel_TextureAmountA;
			sampler2D _Mask2_Rchannel_TextureAmountA;
			//sampler2D _Mask2_Gchannel_TextureAmountA;
			//sampler2D _Mask2_Bchannel_TextureAmountA;

			// Mask
			float4 _MakeUpMask1_RGB_ST;
			float4 _MakeUpMask2_RGB_ST;
			float4 _Mask1_Rchannel_ColorAmountA;
			float4 _Mask1_Gchannel_ColorAmountA;
			float4 _Mask1_Bchannel_ColorAmountA;
			float4 _Mask1_Achannel_ColorAmountA;
			float4 _Mask2_Rchannel_ColorAmountA;
			//float4 _Mask2_Gchannel_ColorAmountA;
			//float4 _Mask2_Bchannel_ColorAmountA;

			float4 _Mask1_Rchannel_TextureAmountA_ST;
			float4 _Mask1_Gchannel_TextureAmountA_ST;
			float4 _Mask1_Bchannel_TextureAmountA_ST;
			float4 _Mask1_Achannel_TextureAmountA_ST;
			float4 _Mask2_Rchannel_TextureAmountA_ST;
			//float4 _Mask2_Gchannel_TextureAmountA_ST;
			//float4 _Mask2_Bchannel_TextureAmountA_ST;

			sampler2D _ClothMask1;
			sampler2D _ClothMask2;
			sampler2D _ClothMask3;

			struct v2f
			{
				float4 pos : SV_POSITION;
				float4 uv : TEXCOORD0;
				float4 worldPos : TEXCOORD1;
				half4 wNormal   : TEXCOORD2;
				half4 wTangent  : TEXCOORD3;
				//half4 shadowPos : TEXCOORD4;
				//float4 viewPos  : TEXCOORD5;
				UNITY_LIGHTING_COORDS(4,5)


				//UNITY_FOG_COORDS(8)
			};

			half4 AddMaskColor(half3 baseColor, float2 uv) {
				half4 albedoAlpha = half4(baseColor,1);

				float2 uv_MakeUpMask1_RGB = uv.xy * _MakeUpMask1_RGB_ST.xy + _MakeUpMask1_RGB_ST.zw;
				float4 tex2DNode143 = tex2D(_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 = tex2D(_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 = tex2D(_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 = tex2D(_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 = tex2D(_Mask1_Achannel_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 = tex2D(_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 = tex2D(_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 = tex2D(_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 = tex2D(_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(lerpResult162.r, lerpResult162.g, lerpResult162.b);

				return albedoAlpha;
			}

			half4 GetColor(float2 uv) {
				//half4 albedoAlpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv) * _BaseColor;
				half4 albedoAlpha = tex2D(_BaseMap, uv) * _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);
				float4 tex2DNode143 = tex2D(_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);
				float4 tex2D_mask1_R = tex2D(_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);
				float4 tex2D_mask1_G = tex2D(_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);
				float4 tex2D_mask1_B = tex2D(_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_Achannel_TextureAmountA, sampler_Mask1_Achannel_TextureAmountA, uv_Mask1_Achannel_TextureAmountA);
				float4 tex2D_mask1_A = tex2D(_Mask1_Achannel_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);
				float4 tex2D_mask2_R = tex2D(_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);
				//float4 tex2D_mask2_G = tex2D(_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);
				//float4 tex2D_mask2_B = tex2D(_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);
				float4 tex2DNode144 = tex2D(_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(lerpResult162.r, lerpResult162.g, lerpResult162.b);

				return albedoAlpha;
			}

			fixed3 GetAlbedo (v2f i) {
				fixed3 albedo = tex2D(_BaseMap, i.uv.xy * _BaseMap_ST.xy + _BaseMap_ST.zw).rgb * _BaseColor.rgb;
				//fixed3 albedo = GetColor(i.uv.xy).rgb;
				return albedo;
			}

			float3 GetMetalSmooth (v2f i){
				float3 metalSmooth = tex2D(_MetalSmoothTex, i.uv.xy).rgb;
				metalSmooth.g *= _Metalness;
				metalSmooth.r *= _Roughness;
				return metalSmooth;
			}

			float3 GetEmission (v2f i) {
				return tex2D(_EmissiveTex, i.uv.xy).rgb;
			}

			float3 GetTangentSpaceNormal (v2f i){
				float3 normal = float3(0, 0, 1);
				normal = UnpackScaleNormal(tex2D(_BumpMap, i.uv.xy), 1.0);
				return normal;
			}

			float3 CreateBinormal (float3 normal, float3 tangent, float binormalSign){
				return cross(normal, tangent.xyz) * (binormalSign * unity_WorldTransformParams.w);
			}

			void InitializeFragmentNormal(inout v2f i){
				float3 tangentSpaceNormal = GetTangentSpaceNormal(i);
				float3 binormal = CreateBinormal(i.wNormal.xyz, i.wTangent.xyz, i.wTangent.w);
				i.wNormal.xyz = normalize(tangentSpaceNormal.x * i.wTangent + tangentSpaceNormal.y * binormal + tangentSpaceNormal.z * i.wNormal.xyz);
			}

			float D(float NdotH, float roughness){
				//float a2 = roughness * roughness + 0.0040000002;
				float a2 = max(roughness * roughness, 0.002);
				float a4 = a2 * a2;
				float d = (NdotH * a4 - NdotH) * NdotH + 1.0f;
				return a4 / (d * d);
			}

			float G(float NdotL, float NdotV, float roughness){
				//float a2 = roughness * roughness;
				//float a4 = a2 * a2;
				//float k = (a4 + 1.0f) * (a4 + 1.0f) /8.0;
				float a2 = roughness * 0.5 + 0.5;
				float k = a2 * a2;
				float g = 0.25 / ((NdotL * (1.0 - k) + k) * (NdotV * (1.0 - k) + k));
				return g;
			}

			float3 F(float VdotH, float3 specColor){
				return (clamp ((50.0 * specColor.y), 0.0, 1.0) - specColor) * exp2((((-5.5547299 * VdotH) + (- 6.98316)) * VdotH)) + specColor;
			}

			inline float3 Shade4PointLightsSpecCol(float4 worldPos, half3 normal, float3 viewDir, float roughness, float skinMask, float NDotV, float3 specColor, out float3 sh){
				 // to light vectors
				  float4 toLightX = unity_4LightPosX0 - worldPos.x;
				  float4 toLightY = unity_4LightPosY0 - worldPos.y;
				  float4 toLightZ = unity_4LightPosZ0 - worldPos.z;
				  // squared lengths
				  float4 lengthSq = 0;
				  lengthSq += toLightX * toLightX;
				  lengthSq += toLightY * toLightY;
				  lengthSq += toLightZ * toLightZ;
				  // don't produce NaNs if some vertex position overlaps with the light
				  lengthSq = max(lengthSq, 0.000001);
				  // NdotL
				  float4 ndotl = 0;
				  ndotl += toLightX * normal.x;
				  ndotl += toLightY * normal.y;
				  ndotl += toLightZ * normal.z;
				  // correct NdotL
				  float4 corr = rsqrt(lengthSq);
				  ndotl = max (float4(0,0,0,0), ndotl * corr);
				  // attenuation
				  float4 atten = 1.0 / (1.0 + lengthSq * unity_4LightAtten0);
				  //float4 diff = ndotl * atten;

				  // halfVec
				  float4 halfX = unity_4LightPosX0 + viewDir.x;
				  float4 halfY = unity_4LightPosY0 + viewDir.y;
				  float4 halfZ = unity_4LightPosZ0 + viewDir.z;

				  float4 lengthHalfSq = 0;
				  lengthHalfSq += halfX * halfX;
				  lengthHalfSq += halfY * halfY;
				  lengthHalfSq += halfZ * halfZ;
				  lengthHalfSq = max(lengthHalfSq, 0.000001);

				  float4 ndoth = 0;
				  ndoth += halfX * normal.x;
				  ndoth += halfY * normal.y;
				  ndoth += halfZ * normal.z;

				  float4 corrHalf = rsqrt(lengthHalfSq);
				  ndoth = max (float4(0,0,0,0), ndoth * corrHalf);

				  float4 vdoth = 0;
				  vdoth += halfX * viewDir.x;
				  vdoth += halfY * viewDir.y;
				  vdoth += halfZ * viewDir.z;
				  vdoth = max (float4(0,0,0,0), vdoth * corrHalf);
				  //d
				  float a2 = max ((roughness * roughness), 0.002);
				  float a4 = (a2 * a2);
				  float4 d = ((ndoth * a4 - ndoth) * ndoth) + 1.0;
				  d = a4 / (d * d);
				  //g
				  float b2 = 0.5 + (0.5 * roughness);
				  float k = (b2 * b2);
				  float4 g = 0.25 / ((ndotl * (1.0 - k) + k) * (NDotV * (1.0 - k) + k));
				  //f
				  float4 f = exp2((((-5.5547299 * vdoth) + (- 6.98316)) * vdoth));
				  half3 oneMinusSpecColor = clamp ((50.0 * specColor.y), 0.0, 1.0) - specColor;
				  //compute
				  float4 a = d * g * f * ndotl;
				  float4 b = d * g * ndotl;
				  half3 col[4];
				  col[0] = unity_LightColor[0].rgb * atten.x;
				  col[1] = unity_LightColor[1].rgb * atten.y;
				  col[2] = unity_LightColor[2].rgb * atten.z;
				  col[3] = unity_LightColor[3].rgb * atten.w;
				  float3x4 colorAtten = {col[0].x, col[1].x, col[2].x, col[3].x, col[0].y, col[1].y, col[2].y, col[3].y, col[0].z, col[1].z, col[2].z, col[3].z};
				  float3 scatterColor = (_SkinSSSScatterColor * skinMask).xyz;
				  sh = (mul(colorAtten, ndotl) + (col[0] + col[1] + col[2] + col[3]) * scatterColor) / (scatterColor + 1.0) * _PointLightExposure;
				  return mul(colorAtten, a) * oneMinusSpecColor + mul(colorAtten, b) * specColor;
			}

			half3 SH(half3 normal, inout float3 refDir){

					(_envRot[0].x = 1.0);
					(_envRot[0].y = 0.0);
					(_envRot[0].z = 0.0);
					(_envRot[0].w = 0.0);
					(_envRot[1].x = 0.0);
					(_envRot[1].y = 1.0);
					(_envRot[1].z = 0.0);
					(_envRot[1].w = 0.0);
					(_envRot[2].x = 0.0);
					(_envRot[2].y = 0.0);
					(_envRot[2].z = 1.0);
					(_envRot[2].w = 0.0);
					(_envRot[3].x = 0.0);
					(_envRot[3].y = 0.0);
					(_envRot[3].z = 0.0);
					(_envRot[3].w = 1.0);
				  refDir = mul(_envRot , refDir).xyz;
				  float4 tmpvar_41 = mul(_envRot , half4(normal, 1.0));

				//_envSHR = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
					(_envSHR[0].x = 0.046);
					(_envSHR[0].y = 0.0);
					(_envSHR[0].z = 0.0);
					(_envSHR[0].w = 0.0);
					(_envSHR[1].x = 0.036);
					(_envSHR[1].y = -0.046);
					(_envSHR[1].z = 0.0);
					(_envSHR[1].w = 0.0);
					(_envSHR[2].x = -0.021);
					(_envSHR[2].y = -0.049);
					(_envSHR[2].z = 0.02);
					(_envSHR[2].w = 0.0);
					(_envSHR[3].x = 0.109);
					(_envSHR[3].y = 0.131);
					(_envSHR[3].z = -0.09);
					(_envSHR[3].w = 0.569);
					 //_envSHG = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
					(_envSHG[0].x = 0.043);
					(_envSHG[0].y = 0.0);
					(_envSHG[0].z = 0.0);
					(_envSHG[0].w = 0.0);
					(_envSHG[1].x = 0.066);
					(_envSHG[1].y = -0.043);
					(_envSHG[1].z = 0.0);
					(_envSHG[1].w = 0.0);
					(_envSHG[2].x = -0.03);
					(_envSHG[2].y = -0.072);
					(_envSHG[2].z = 0.018);
					(_envSHG[2].w = 0.0);
					(_envSHG[3].x = 0.134);
					(_envSHG[3].y = 0.145);
					(_envSHG[3].z = -0.118);
					(_envSHG[3].w = 0.466);
					// _envSHB = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
					(_envSHB[0].x = 0.036);
					(_envSHB[0].y = 0.0);
					(_envSHB[0].z = 0.0);
					(_envSHB[0].w = 0.0);
					(_envSHB[1].x = 0.091);
					(_envSHB[1].y = -0.036);
					(_envSHB[1].z = 0.0);
					(_envSHB[1].w = 0.0);
					(_envSHB[2].x = -0.025);
					(_envSHB[2].y = -0.091);
					(_envSHB[2].z = 0.012);
					(_envSHB[2].w = 0.0);
					(_envSHB[3].x = 0.14);
					(_envSHB[3].y = 0.142);
					(_envSHB[3].z = -0.126);
					(_envSHB[3].w = 0.394);
				  float3 tmpvar_42;
				  tmpvar_42.x = dot (tmpvar_41, mul(_envSHR , tmpvar_41));
				  tmpvar_42.y = dot (tmpvar_41, mul(_envSHG , tmpvar_41));
				  tmpvar_42.z = dot (tmpvar_41, mul(_envSHB , tmpvar_41));
				  half3 sRGB = tmpvar_42;
				  half3 SHColor = GammaToLinearSpace(sRGB);

				  return SHColor;
			}

			half3 IBL(half3 linearAlbedo, half3 metalSmooth, float NDotV, float3 reflectonDir){
				float roughnessLod = (0.04859 + 14.8158 * metalSmooth.r) - (7.45063 * metalSmooth.r) * metalSmooth.r;
				float refDirTexcoordV = abs(reflectonDir.y) * -0.03102955 + 0.086566716;
				refDirTexcoordV = abs(reflectonDir.y) * refDirTexcoordV - 0.2146018;
				refDirTexcoordV = abs(reflectonDir.y) * refDirTexcoordV + UNITY_HALF_PI;
				refDirTexcoordV = UNITY_HALF_PI - sqrt(1.0 - abs(reflectonDir.y)) * refDirTexcoordV;
				refDirTexcoordV = UNITY_HALF_PI - sign(reflectonDir.y) * refDirTexcoordV;

				float refDirU = (min (abs(reflectonDir.z / reflectonDir.x), 1.0) / max (abs(reflectonDir.z / reflectonDir.x), 1.0));
				float SqrtRefDirTexcoordU = refDirU * refDirU;
				float refDirTexcoordU = -0.01213232 * SqrtRefDirTexcoordU + 0.053681381;
				refDirTexcoordU = refDirTexcoordU * SqrtRefDirTexcoordU - 0.1173503;
				refDirTexcoordU = refDirTexcoordU * SqrtRefDirTexcoordU + 0.19389249;
				refDirTexcoordU = refDirTexcoordU * SqrtRefDirTexcoordU - 0.33267561;
				refDirTexcoordU = refDirTexcoordU * SqrtRefDirTexcoordU + 0.99997932;
				refDirTexcoordU =  refDirTexcoordU * refDirU;
				refDirTexcoordU = refDirTexcoordU + (abs(reflectonDir.z / reflectonDir.x) > 1.0) * ((refDirTexcoordU * -2.0) + UNITY_HALF_PI);
				refDirTexcoordU = refDirTexcoordU * sign(reflectonDir.z / reflectonDir.x);

				if (abs(reflectonDir.x) > (1e-08 * abs(reflectonDir.z))) {
					if (reflectonDir.x < 0.0) {
					  if (reflectonDir.z >= 0.0) {
						refDirTexcoordU += UNITY_PI;
					  } else {
						refDirTexcoordU = (refDirTexcoordU - UNITY_PI);
					  };
					};
				  } else {
					refDirTexcoordU = (sign(reflectonDir.z) * UNITY_HALF_PI);
				};
				float2 uv;
				uv.x = clamp ((0.5 + refDirTexcoordU / UNITY_TWO_PI), 0.0, 1.0);
				uv.y = 1.0 - clamp (refDirTexcoordV / UNITY_PI, 0.0, 1.0);
				fixed4 envRefCol = tex2Dlod (_EnvironmentTex, float4(uv, 0, roughnessLod));
			    float3 envCol = envRefCol.xyz * envRefCol.w;
				float4 roughnessCol = metalSmooth.r * float4(-1.0, -0.0275, -0.572, 0.022) + float4(1.0, 0.0425, 1.04, -0.04);
				float2 roughness = float2(-1.04, 1.04) * (min ((roughnessCol.x * roughnessCol.x), exp2(-9.28 * NDotV)) * roughnessCol.x + roughnessCol.y) + roughnessCol.zw;
				float3 albedoCol = lerp (0.04, linearAlbedo, metalSmooth.g);
				float roughnessRim = clamp ((roughness.y - 0.01), 0.0, 1.0);
				half3 envSpecular = (((albedoCol * roughness.x) + roughnessRim) * (18.84956 * (envCol * envCol))) * _EnvExposure;
				return envSpecular;
			}

			inline float3 BoxProjection(float3 direction, float3 position, float4 cubemapPosition, float3 boxMin, float3 boxMax){
				#if UNITY_SPECCUBE_BOX_PROJECTION
					UNITY_BRANCH
					if(cubemapPosition.w > 0){
						float3 factors = ((direction > 0 ? boxMax : boxMin) - position) / direction;
						float scalar = min(min(factors.x, factors.y), factors.z);
						direction = direction * scalar + (position - cubemapPosition);
					}
				#endif
				return direction;
			}

			inline half3 SHEval(half3 normal) {
				half4 n = half4(normal, 1.0);
				half3 x1, x2, x3;

				// Linear + constant polynomial terms
				x1.r = dot(unity_SHAr,n);
				x1.g = dot(unity_SHAg,n);
				x1.b = dot(unity_SHAb,n);

				// 4 of the quadratic polynomials
				half4 vB = n.xyzz * n.yzzx;
				x2.r = dot(unity_SHBr,vB);
				x2.g = dot(unity_SHBg,vB);
				x2.b = dot(unity_SHBb,vB);

				// Final quadratic polynomial
				half vC = n.x*n.x - n.y*n.y;
				x3 = unity_SHC.rgb * vC;

				return x1 + x2 + x3;
			}

			inline half3 DarkCornerColor(in float3 col, float3 viewDir){
				float camSpaceDir = mul(unity_MatrixV, float4(viewDir, 0)).z;
				float squCamSpaceDir = camSpaceDir * camSpaceDir;
				float biquCamSpaceDir = squCamSpaceDir * squCamSpaceDir;
				float dark = biquCamSpaceDir * biquCamSpaceDir;
				dark = dark * dark;
				float3 darkCornerColor = (dark + _DarkCornerColor) - (dark * _DarkCornerColor);

				_HeroShowOverallExposureColor = fixed4(1,1,1,1);
				return col * (_HeroShowOverallExposureColor.xyz * darkCornerColor);
			}

			UnityIndirect CreateGI(half3 normal, float3 refDir, float3 worldPos, half roughness){
				UnityIndirect indirectLight;
				indirectLight.diffuse = 0;
				indirectLight.specular = 0;

				indirectLight.diffuse = max (SHEval(normal), 0.0);

				Unity_GlossyEnvironmentData envData;
				envData.roughness = roughness;
				envData.reflUVW = BoxProjection(refDir, worldPos.xyz, unity_SpecCube0_ProbePosition, unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
				indirectLight.specular = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData);
				return indirectLight;
			}

			half4 BRDF_KingHonour_PBS(v2f i, float4 worldPos, half3 linearAlbedo, half3 albedo, half3 metalSmooth, half3 normal, float3 viewDir, float3 refDir, half3 effCol, float NDotH, float VDotH, float NDotV, float atten, UnityLight light){
				half3 diffColor = linearAlbedo * (1.0 - metalSmooth.g);
				half3 specColor = lerp (0.04, linearAlbedo, metalSmooth.g);
				float skinMask = clamp ((effCol.r - 0.1), 0.0, 1.0) * 1.1 * _SkinSSSTransmission;
				float3 skinRim = ((float3(0.66, 2.34, 2.34) * ((albedo.y * albedo.z) * _SkinSSSfresnelMask)) * ((1.0 - NDotV) * (1.0 - NDotV))) * skinMask;
				float oneMinusNDotV = 1.0 - NDotV;
				float rimEnv = lerp (metalSmooth.z * metalSmooth.z, 1.0, (oneMinusNDotV * oneMinusNDotV));

				//half3 shColor = SH(normal, refDir);
				//shColor *= _SHExposure;
				UnityIndirect indirectLight = CreateGI(normal, refDir, worldPos, metalSmooth.r);

				half3 shColor = indirectLight.diffuse * _SHExposure;

				half3 scatterColor = (_SkinSSSScatterColor * skinMask).xyz;
				half3 tmpvar_59 = _DirLightColor.xyz;// * i.worldPos.w;
				///Shadow Color
				half3 scatterCol = min (light.ndotl, atten) + scatterColor;
				float3 shAndSkinColor = shColor * rimEnv + max (lerp(scatterCol * _ShadowCol , scatterCol , atten) / (scatterColor + 1.0), 0.0) * _DirLightExposure * tmpvar_59;
				///
				//float3 shAndSkinColor = shColor * rimEnv + max (((min (light.ndotl, atten) + scatterColor) / (scatterColor + 1.0)), 0.0) * _DirLightExposure * tmpvar_59;
				float d = D(NDotH, metalSmooth.r);
				float g = G(light.ndotl, NDotV, metalSmooth.r);
				half3 f = F(VDotH, specColor);
				//half3 specCol = tmpvar_59 * d * g * f * light.ndotl * atten;
				///Shadow Color
				half3 specCol = tmpvar_59 * d * g * f * light.ndotl;
				specCol = lerp(specCol * _ShadowCol, specCol, atten);
				///
				//branch realtime 4pointLight with in struct's normal.w
				UNITY_BRANCH
				if(i.wNormal.w > 0.0){
					float3 vertexCol;
					half3 pointCol = Shade4PointLightsSpecCol(worldPos, normal, viewDir, metalSmooth.r, skinMask, NDotV, specColor, vertexCol);
					shAndSkinColor += vertexCol;
					specCol += pointCol;
				}



				//half3 envSpecular = IBL(linearAlbedo, metalSmooth, NDotV, refDir);
				half3 envSpecular = GammaToLinearSpace(indirectLight.specular);

				float4 roughnessCol = metalSmooth.r * float4(-1.0, -0.0275, -0.572, 0.022) + float4(1.0, 0.0425, 1.04, -0.04);
				float2 roughness = float2(-1.04, 1.04) * (min ((roughnessCol.x * roughnessCol.x), exp2(-9.28 * NDotV)) * roughnessCol.x + roughnessCol.y) + roughnessCol.zw;
				float roughnessRim = clamp ((roughness.y - 0.01), 0.0, 1.0);
				envSpecular = (((specColor * roughness.x) + roughnessRim) * (18.84956 * (envSpecular * (envSpecular + _envBDRFFactor)))) * _EnvExposure;

				///Right indirect specular color
				float surfaceReduction = 1.0 / (roughness * roughness + 1.0); //Liner空间
				float oneMinusReflectivity = 1 - max(max(specColor.r, specColor.g), specColor.b);
				float grazingTerm = saturate(1 - metalSmooth.r + (1 - oneMinusReflectivity));
				half3 rightIndirSpec = surfaceReduction * FresnelLerp(specColor, grazingTerm, NDotV);
				///
				specCol = specCol * _PunctualLightSpecularExposure + envSpecular * rimEnv * rightIndirSpec;
				float emissiveMask = clamp ((effCol.y - 0.1), 0.0, 1.0) * 1.1 * _EmissionExposure;
				float3 emissiveCol = (emissiveMask * linearAlbedo) * _EmissionCol;
				half3 col = (shAndSkinColor * diffColor + skinRim) + (specCol + emissiveCol);
				//half3 col = specCol;

				col = DarkCornerColor(col, viewDir);
				half4 finalCol;
				finalCol.w = 1.0;

				#ifdef MANUAL_LINEAR_SPACE
					float bloomFactor = sqrt(max ((dot (col, float3(0.299, 0.587, 0.114)) - _Global_BloomThreshold), 0.0) * _BloomIntensity);
					bloomFactor = bloomFactor / (1.0 + bloomFactor);
					finalCol.w = bloomFactor;
					finalCol.rgb = (col / (col + 0.187)) * 1.035;
				#else
					col = (col * ((2.51 * col) + 0.03)) / ((col * ((2.43 * col) + 0.59)) + 0.14);
					finalCol.rgb = LinearToGammaSpace(col);
				#endif
				return finalCol;
			}
		ENDCG

		SubShader
		{
			Tags { "Queue" = "Geometry" "RenderType"="Opaque" "MirrorReplace" = "Mirror" "ignoreprojector" = "true" }
			LOD 500

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

				#pragma vertex vert
				#pragma fragment frag

				#pragma multi_compile_fwdbase

				//#pragma shader_feature _ _SGAME_HIGH_QUALITY_SHADOW_ON MANUAL_LINEAR_SPACE
				#pragma target 3.0


				//#define _SGAME_HIGH_QUALITY_SHADOW_ON
				//#define MANUAL_LINEAR_SPACE

				v2f vert (appdata_full v)
				{
				  v2f o;
				  UNITY_SETUP_INSTANCE_ID(v);
				  UNITY_INITIALIZE_OUTPUT(v2f, o);
				  o.pos = UnityObjectToClipPos(v.vertex);
				  o.uv.xy = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
				  float4 worldVertex = mul(unity_ObjectToWorld, v.vertex);
				  o.wNormal.xyz = UnityObjectToWorldNormal(v.normal);
				  /*
				  /////
				  float4 shadowPos_9;
				  float4 shadowVertex = mul(_SGameShadowMatrix , worldVertex);
				  shadowPos_9.w = shadowVertex.w;
				  shadowPos_9.xyz = (shadowVertex.xyz / shadowVertex.w);
				  shadowPos_9.xyz = shadowPos_9.xyz * 0.5 + 0.5;
				  o.shadowPos.xyz = shadowPos_9.xyz;
				  /////


				  //////
				  o.viewPos = mul(UNITY_MATRIX_V, worldVertex);
				  float3 lightDir = (worldVertex.xyz - _DirLightPos.xyz);
				  _SGameShadowParams.xyz = -_WorldSpaceLightPos0.xyz;
				  float NDotV = dot (lightDir, _SGameShadowParams.xyz);
				  float3 x_15 = (lightDir - (NDotV * _SGameShadowParams.xyz));

				  float x_17 = (clamp ((1.0 - ((sqrt(dot (x_15, x_15)) - _DirLightRanges.x) / (_DirLightRanges.y - _DirLightRanges.x))), 0.0, 1.0) + 0.0001);
				  half NDotL = pow (x_17, _DirLightAttens.x);
				  float atten1_12 = NDotL;

				  float x_19 = (clamp ((1.0 - ((NDotV - _DirLightRanges.z) / (_DirLightRanges.w - _DirLightRanges.z)).x), 0.0, 1.0) + 0.0001);
				  half tmpvar_18 = pow (x_19, _DirLightAttens.y);
				  float atten2_11 = tmpvar_18;
				  worldVertex.w = max (atten1_12 * atten2_11, _DirLightAttens.z);
				  //////

				  #ifdef _SGAME_POINT_LIGHT_ON

					_PointLightPosAndRange = fixed4(-29.167,-30.527,106.016,2.3);
					float3 tmpvar_20 = ((worldVertex.xyz - _PointLightPosAndRange.xyz) / _PointLightPosAndRange.w);

					_PointLightColorAndAtten = fixed4(0,0,0,3.1);
					o.shadowPos.w = pow (clamp ((1.0 - dot (tmpvar_20, tmpvar_20)), 0.0, 1.0), (_PointLightColorAndAtten.w + 0.001));
				  #else
					o.shadowPos.w = clamp (dot (-(o.wNormal), normalize(_SGameShadowParams.xyz)), 0.0, 1.0);
				  #endif
				  */

				  #ifdef VERTEXLIGHT_ON
					  o.wNormal.w = 1.0;
				  #else
					  o.wNormal.w = 0.0;
				  #endif

				  o.worldPos = worldVertex;
				  o.wTangent.xyz = UnityObjectToWorldDir(v.tangent.xyz);
				  o.wTangent.w = v.tangent.w;
				  //We need this for shadow receving
				  UNITY_TRANSFER_LIGHTING(o, v.texcoord1);

				  return o;
				}

				fixed4 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);
					UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
					half3 albedo = GetAlbedo(i);
					half3 linearAlbedo = GammaToLinearSpace(albedo);
					linearAlbedo = AddMaskColor(linearAlbedo,i.uv.xy).rgb;
					float3 metalSmooth = GetMetalSmooth(i);
					half3 effCol = GetEmission(i);
					float4 worldPos = i.worldPos;

					UnityLight light;
					light.dir = UnityWorldSpaceLightDir(worldPos);
				    #ifndef USING_DIRECTIONAL_LIGHT
					    light.dir = normalize(light.dir);
				    #endif
					light.color = _LightColor0.rgb;

					InitializeFragmentNormal(i);
					half3 worldNormal = i.wNormal.xyz;
					float3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
					float3 refLight = reflect(-viewDir, worldNormal);
					float NDotV = clamp(dot(worldNormal, viewDir), 0.01, 1.0);
					light.ndotl = clamp(dot(worldNormal, light.dir), _CosMin, 1.0);
					float3 halfDir = Unity_SafeNormalize(float3(light.dir) + viewDir);
					//float NDotH = saturate(dot(worldNormal, halfDir));
					//float VDotH =  saturate(dot(viewDir, halfDir));
					float NDotH = clamp(dot(worldNormal, halfDir), _CosMin, 1.0);
					float VDotH =  clamp(dot(viewDir, halfDir), 0.01, 1.0);

					UNITY_LIGHT_ATTENUATION(atten, i, worldPos.xyz);

					atten = max(atten, _ShadowDarkness);

					half4 col = BRDF_KingHonour_PBS(i, worldPos, linearAlbedo, albedo, metalSmooth, worldNormal, viewDir, refLight, effCol, NDotH, VDotH, NDotV, atten, light);
					col = saturate(col);
					return col;
				}
				ENDCG
			}

			//Pass{
			//	Blend One One
			//	Name "Bloom_Mask"
			//	Tags { "LightMode"="ForwardAdd"}
			//	CGPROGRAM
			//	#pragma vertex vert_Bloom
			//	#pragma fragment frag_Bloom
			//	#pragma exclude_renderers xboxone ps4 psp2 n3ds wiiu

			//	struct v2f_Bloom
			//	{
			//		float4 pos      : SV_POSITION;
			//		float4 uv       : TEXCOORD0;
			//	};

			//	sampler2D _BloomTex;

			//	v2f_Bloom vert_Bloom(appdata_base v){
			//		v2f_Bloom o;
			//		UNITY_INITIALIZE_OUTPUT(v2f_Bloom, o);
			//		o.pos = UnityObjectToClipPos(v.vertex);
			//		o.uv.xy = v.texcoord.xy;
			//		return o;
			//	}

			//	half4 frag_Bloom(v2f_Bloom i):SV_Target{
			//		half4 bloomMask = tex2D(_BloomTex, i.uv);
			//		return bloomMask;
			//	}

			//	ENDCG
			//}

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

				CGPROGRAM
				#pragma vertex ShadowVertex
				#pragma fragment ShadowFrag

				#pragma glsl_no_auto_normalization
				#pragma exclude_renderers xboxone ps4 psp2 n3ds wiiu

				//#include "UnityCG.cginc"

				#if defined(_RENDERING_FADE) || defined(_RENDERING_TRANSPARENT)
					#if defined(_SEMITRANSPARENT_SHADOWS)
						#define SHADOWS_SEMITRANSPARENT 1
					#else
						#define _RENDERING_CUTOUT
					#endif
				#endif

				#if SHADOWS_SEMITRANSPARENT || defined(_RENDERING_CUTOUT)
					#if !defined(_SMOOTHNESS_METALLIC)
						#define SHADOWS_NEED_UV 1
					#endif
				#endif

				float _CutOff;
				sampler3D _DitherMaskLOD;

				struct VertexData {
					float4 position : POSITION;
					float3 normal : NORMAL;
					float2 uv : TEXCOORD0;
					UNITY_VERTEX_INPUT_INSTANCE_ID
				};

				struct InterpolatorsVertex {
					float4 position : SV_POSITION;
					#if SHADOWS_NEED_UV
						float2 uv : TEXCOORD0;
					#endif
					#if defined(SHADOWS_CUBE)
						float3 lightVec : TEXCOORD1;
					#endif
					UNITY_VERTEX_INPUT_INSTANCE_ID
				};

				struct Interpolators {
					#if SHADOWS_SEMITRANSPARENT
						float4 vpos : VPOS;
					#else
						float4 positions : SV_POSITION;
					#endif

					#if SHADOWS_NEED_UV
						float2 uv : TEXCOORD0;
					#endif
					#if defined(SHADOWS_CUBE)
						float3 lightVec : TEXCOORD1;
					#endif
					UNITY_VERTEX_INPUT_INSTANCE_ID
				};

				float GetAlpha (Interpolators i) {
					float alpha = 1.0;
					#if SHADOWS_NEED_UV
						alpha *= tex2D(_MainTex, i.uv.xy).a;
					#endif
					return alpha;
				}

				half RoughnessSetup_ShadowGetOneMinusReflectivity(half2 uv)
				{
					half metallicity = _Metalness;
				#ifdef _GLOSSMAP
					metallicity = tex2D(_MetalSmoothTex, uv).g;
				#endif
					return OneMinusReflectivityFromMetallic(metallicity);
				}

				InterpolatorsVertex ShadowVertex (VertexData v) {
					UNITY_SETUP_INSTANCE_ID(v);
					InterpolatorsVertex i;
					UNITY_INITIALIZE_OUTPUT(InterpolatorsVertex, i);
					UNITY_TRANSFER_INSTANCE_ID(v,i);
					UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(i);
					#if defined(SHADOWS_CUBE)
						i.position = UnityObjectToClipPos(v.position);
						i.lightVec =
							mul(unity_ObjectToWorld, v.position).xyz - _LightPositionRange.xyz;
					#else
						i.position = UnityClipSpaceShadowCasterPos(v.position.xyz, v.normal);
						i.position = UnityApplyLinearShadowBias(i.position);
					#endif

					#if SHADOWS_NEED_UV
						i.uv = TRANSFORM_TEX(v.uv, _MainTex);
					#endif
					return i;
				}

				float4 ShadowFrag (Interpolators i) : SV_TARGET {
					UNITY_SETUP_INSTANCE_ID(i);
					float alpha = GetAlpha(i);
					#if defined(_RENDERING_CUTOUT)
						clip(alpha - _CutOff);
					#endif

					#if SHADOWS_SEMITRANSPARENT
						#if defined(_ALPHAPREMULTIPLY_ON)
							   half outModifiedAlpha;
							   PreMultiplyAlpha(half3(0, 0, 0), alpha, RoughnessSetup_ShadowGetOneMinusReflectivity(i.uv), outModifiedAlpha);
							   alpha = outModifiedAlpha;
						#endif
						float dither =
							tex3D(_DitherMaskLOD, float3(i.vpos.xy * 0.25, alpha * 0.9375)).a;
						clip(dither - 0.01);
					#endif

					#if defined(SHADOWS_CUBE)
						float depth = length(i.lightVec) + unity_LightShadowBias.x;
						depth *= _LightPositionRange.w;
						return UnityEncodeCubeShadowDepth(depth);
					#else
						return 0;
					#endif
				}

				ENDCG
			}
		}
	}// Category

}