Shader "SGame/Particles/Effect_Multiple" 
{
    Properties
	{
        [HideInInspector]_ValueCustomData ("颜色强度CustomData", Float) = 0
		[HideInInspector]_Value ("总颜色强度", Float) = 1
		[HideInInspector]_Color("颜色混色", Color) = (1, 1, 1, 1)
        [HideInInspector]_CutOff ("透贴开关", Float) = 0
        [HideInInspector]_CutOffAlpha("透贴Alpha阈值", Range(0, 1)) = 0
		[HideInInspector]_Texture ("基础贴图", 2D) = "white" {}
        [HideInInspector]_TexuteRorAlpha ("黑底开关", Float) = 0
        [HideInInspector]_MainTexCustomData ("基础贴图CustomData开关", Float) = 0
		[HideInInspector]_MainTexUSpeed ("基础贴图流动U", Float) = 0
		[HideInInspector]_MainTexVSpeed ("基础贴图流动V", Float) = 0

        [Space(10)]
        [HideInInspector]_Mask ("遮罩贴图", 2D) = "white" {}
        [HideInInspector]_MaskUseR ("遮罩是否黑底", Float) = 0
        [HideInInspector]_MaskTexCustomData ("遮罩CustomData开关", Float) = 0
        [HideInInspector]_MaskTexColorSwitch ("遮罩颜色开关", Float) = 0
        [HideInInspector]_Mask_USpeed ("遮罩流动U Speed", Float) = 0
        [HideInInspector]_Mask_VSpeed ("遮罩流动V Speed", Float) = 0
        [HideInInspector]_MaskIntensity ("遮罩强度", Float) = 1

        [Space(10)]
        [HideInInspector]_RimLight ("边缘光开关", Float) = 0
        [HideInInspector]_RimInverseToggle ("边缘光反向开关", Float) = 0
        [HideInInspector]_ColorOuter ("边缘颜色", Color) = (1, 1, 1, 1)
        [HideInInspector]_ColorInner ("内部颜色", Color) = (1, 1, 1, 1)
        [HideInInspector]_RimIntensity ("边缘强度", Float) = 1
        [HideInInspector]_TextureIntensity ("内部贴图强度", Float) = 1
        [HideInInspector]_bianyuan ("边缘光偏移", Float) = 1

        [Space(10)]
        [HideInInspector]_Dissolve ("溶解开关", Float) = 0
		[HideInInspector]_NoiseTex("溶解图", 2D) = "white" {}
        [HideInInspector]_NoiseUSpeed ("溶解动画USpeed", Float) = 0
        [HideInInspector]_NoiseVSpeed ("溶解动画VSpeed", Float) = 0
        [Space(3)]
        [HideInInspector]_ThresholdToggle ("溶解度反向", Float) = 0
        [HideInInspector]_DissCustomData ("溶解度流动CustomData", Float) = 0
		[HideInInspector]_Threshold("溶解度", Range(-1, 3)) = 2
        [HideInInspector]_EdgeHardness ("溶解边缘硬度", Range(0, 0.5)) = 0
        [HideInInspector]_EdgeIntensity ("溶解边缘强度", Float) = 1
		[HideInInspector]_EdgeLength("溶解边缘长度", Range(0, 0.5)) = 0
		[HideInInspector]_EdgeColor("溶解边缘颜色", Color) = (0, 0, 0, 1)

        [Space(10)]
        [HideInInspector]_DistortionCustomData ("扭曲CustomData", Float) = 0
        [HideInInspector]_Distortion ("扭曲开关", Float) = 0
        [HideInInspector]_NiuQu ("扭曲贴图", 2D) = "white" {}
        [HideInInspector]_DUspeed ("扭曲贴图动画U", Float ) = 0
        [HideInInspector]_DVsped ("扭曲贴图动画V", Float ) = 0
        [HideInInspector]_DistortUIns ("扭曲U方向强度", Float) = 1
        [HideInInspector]_DistortVIns ("扭曲V方向强度", Float) = 1
        [HideInInspector]_DistortionIntensity ("扭曲强度", Float ) = 0

        [Space(10)]
        [HideInInspector]_Flow("流动开关", Float) = 0
        [HideInInspector]_PolarFlow ("极坐标流动开关", Float) = 0
        [HideInInspector]_FlowAddOn ("流动混合开关", Float) = 0
        [HideInInspector]_FlowColor ("流动颜色", Color) = (0, 0, 0, 1)
        [HideInInspector]_FlowStrength ("流动贴图强度", Float) = 0
        [HideInInspector]_FlowTex ("流动贴图", 2D) = "white" {}
        [HideInInspector]_FlowCustomData ("流动CustomData", Float) = 0
        [HideInInspector]_FlowUSpeed ("流动USpeed", Float) = 0
        [HideInInspector]_FlowVSpeed ("流动VSpeed", Float) = 0
        // [HideInInspector]_FlowCutPart ("极坐标流动缩放", Float) = 1
        [HideInInspector]_FlowAngularSpeed ("极坐标流动角速度", Float) = 0
        [HideInInspector]_FlowLinearSpeed ("极坐标流动线速度", Float) = 0

        [Space(10)]
        [HideInInspector]_FlowMask ("流动遮罩贴图", 2D) = "white" {}
        [HideInInspector]_FlowMaskUseR ("流动遮罩是否黑底", Float) = 0
        [HideInInspector]_FlowMask_USpeed ("流动遮罩流动U Speed", Float) = 0
        [HideInInspector]_FlowMask_VSpeed ("流动遮罩流动V Speed", Float) = 0
        [HideInInspector]_FlowMaskIntensity ("流动遮罩强度", Float) = 1

        //Adding 2021-0515: 顶点偏移
        [Space(10)]
        [HideInInspector]_VertOffset ("顶点偏移开关", Float) = 0
        [HideInInspector]_VertexAnimMap ("顶点动画采样图", 2D) = "Black" {}
        [HideInInspector]_VertexAnimMapUseR ("顶点采样图黑底", Float) = 0
        [HideInInspector]_VertexAnimMapFlow_U ("采样图_U", Float) = 0
        [HideInInspector]_VertexAnimMapFlow_V ("采样图_V", Float) = 0
        [HideInInspector]_VertexAnimOffset_CustomData ("采样CustomData开关", Float) = 0
        [HideInInspector]_VertexAnimIntensity ("偏移强度", Float) = 0
        [HideInInspector]_VertexAnimMapFlow_WorldPos ("世界方向偏移开关", Float) = 0
        [HideInInspector]_VertexAnimMapVec ("偏移方向向量", Vector) = (0, 0, 0, 0)

        [HideInInspector]_VertexAnimMask ("顶点偏移遮罩", 2D) = "White" {}
        [HideInInspector]_VertexAnimMaskUseR ("顶点遮罩是否黑底", Float) = 1
        [HideInInspector]_VertexAnimMapFlowU ("偏移方向-U", Float) = 1
        [HideInInspector]_VertexAnimMapFlowV ("偏移方向-V", Float) = 1
 
        [Space(15)]
		[HideInInspector] _HorizontalLine ("地平面分割线", Float) = -5000
        [HideInInspector] _HorizontalClip ("地平面切割", Float) = 0

        [Enum(Off, 0, On, 1)]_ZRt("深度写入", Float) = 0
		[Enum(Off, 0, On, 2)] _ZTest ("深度测试", Float) = 2
        [Enum(Add, 1, Blend, 10)]_BlendMode("混合模式", Float) = 10
        [Enum(Double, 0, Front, 1, Back, 2)]_CullMode ("面剔除", Float) = 0

        [Space(15)]
		[MaterialToggle] _DECAL ("自行贴地开关", Float) = 0
		_DecalOffset("Z轴偏移，普通为0，需要Z缩放为-0.5", Float) = -0.5
		_EffectFogFactor("特效雾效Factor", Range(0, 1)) = 0

        [Space(15)]
		[MaterialToggle] _FADE ("深度渐变开关", Float) = 0
		_DepthFadeFactor("物体相交深度渐变", Range(1, 8)) = 0
    }

    SubShader
	{
        Tags
		{
            "IgnoreProjector"="True"
            "Queue"="Overlay"
            "RenderType"="Transparent"
            "PreviewType" = "Plane"
            "CameraCap" = "Effect"
			"RenderPipeline" = "UniversalPipeline"
        }
		Blend SrcAlpha [_BlendMode]
        Cull [_CullMode]
        ZWrite [_ZRt] ZTest [_ZTest]
		Lighting Off

        HLSLINCLUDE
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/core.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
			#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

	        #include "../Base/Lighting_Base.hlsl"

            #pragma multi_compile __ _VERTOFFSET_ON
            #pragma multi_compile __ _RIMLIGHT_ON
            #pragma multi_compile __ _DISSOLVE_ON
            #pragma multi_compile __ _DISTORTION_ON
            #pragma multi_compile __ _FLOW_ON
            #pragma multi_compile __ _POLARFLOW_ON
            #pragma multi_compile __ _CUTOFF_ON
			#pragma multi_compile __ _DECAL_ON
			#pragma multi_compile __ _FADE_ON

            CBUFFER_START(UnityPerMaterial)
                half _bianyuan; half4 _ColorOuter; half4 _ColorInner; half _TextureIntensity;
                half _DissCustomData; half _ValueCustomData; half _FlowCustomData; half _MaskTexCustomData; half _MainTexCustomData;
                half _Value; half4 _Color; half4 _Texture_ST; half _MainTexUSpeed; half _MainTexVSpeed; half4 _Mask_ST;
                half _Mask_USpeed; half _Mask_VSpeed; half _MaskIntensity; half _MaskTexColorSwitch; half _EdgeIntensity;
                half4 _NoiseTex_ST; half _NoiseUSpeed; half _NoiseVSpeed; half _Threshold; half _EdgeLength; half4 _EdgeColor;
                half _RimInverseToggle; half _RimIntensity; half _MaskUseR; half _EdgeHardness; half _ThresholdToggle;
                half _DUspeed; half _DVsped; half _DistortionIntensity; half _DistortionCustomData;
                half4 _NiuQu_ST; half _DistortUIns; half _DistortVIns; half _BlendMode; half _TexuteRorAlpha; half4 _FlowColor; half _FlowStrength; 
                half4 _FlowTex_ST; half _FlowUSpeed; half _FlowVSpeed; half _FlowAngularSpeed; half _FlowLinearSpeed; half _FlowAddOn;
                half _FlowMaskUseR; half _FlowMask_USpeed; half _FlowMask_VSpeed; half _FlowMaskIntensity; half4 _FlowMask_ST;

                half _CutOffAlpha; half _HorizontalClip; half _HorizontalLine;
                half4 _VertexAnimMap_ST; half _VertexAnimMapUseR; half _VertexAnimMapFlow_U; half _VertexAnimMapFlow_V;
                half _VertexAnimOffset_CustomData; half _VertexAnimMapFlow_WorldPos; half4 _VertexAnimMapVec; half _VertexAnimIntensity;
                half4 _VertexAnimMask_ST; half _VertexAnimMaskUseR; half _VertexAnimMapFlowU; half _VertexAnimMapFlowV;
                half _FogMultiplier;

                half _DecalOffset; 
                half _EffectFogFactor;
                half _DepthFadeFactor;
            CBUFFER_END

            sampler2D _Texture;
            sampler2D _Mask; 
			sampler2D _NoiseTex; 
            sampler2D _NiuQu; 
            sampler2D _FlowTex; 
            sampler2D _FlowMask; 
            sampler2D _VertexAnimMap; 
            sampler2D _VertexAnimMask; 
            
            struct VertexInput 
			{
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 texcoord0 : TEXCOORD0;
                float4 texcoord2 : TEXCOORD1;
                float4 texcoord3 : TEXCOORD2;
                half4 vertexColor : COLOR;
            };

            struct VertexOutput 
			{
                float4 pos : SV_POSITION;
                float2 uv0 : TEXCOORD0;
                half3 worldViewDir : TEXCOORD1;
                float3 worldNormal : TEXCOORD2;
                float4 uv1 : TEXCOORD3;
                half4 uv2 : TEXCOORD4;
                half4 color : COLOR;
                half3 worldPos : TEXCOORD5;

                float4 texCustomData : TEXCOORD6;

                #if defined(_FADE_ON)
                    float4 screenPos : TEXCOORD7;
                #endif

				#if defined(_DECAL_ON)
					float4 viewRayOS : TEXCOORD11;
					float3 camPosOS : TEXCOORD12;
				    float4 screenUV : TEXCOORD13;
				#endif

            };

            inline float3 UnityObjectToViewPos( in float3 pos )
            {
                return mul(UNITY_MATRIX_V, mul(unity_ObjectToWorld, float4(pos, 1.0))).xyz;
            }
            #define COMPUTE_EYEDEPTH(o, vert) o = -UnityObjectToViewPos( vert ).z

			inline half2 GetPolarCoords(half2 uv, half linearSpeed, half angularSpeed, half flowPart)
			{
				half2 tempUV = uv * 2 - 1;
				half x = length(tempUV);
				half y = (atan2(tempUV.x, tempUV.y) / 6.283) + 0.5;
				half2 offset = half2(linearSpeed, angularSpeed) * _Time.y + _FlowTex_ST.zw;
				return half2(x, y) * (flowPart + _FlowTex_ST.xy) + offset;
			}

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

			//DECAL
			#if defined(_DECAL_ON)
                o.uv1 = v.texcoord2;
			#else
                half2 uvOffsetMain = _MainTexCustomData * v.texcoord2.xy + (1 - _MainTexCustomData) * half2(_MainTexUSpeed, _MainTexVSpeed) * _Time.y;
                half2 uvOffsetMask = _MaskTexCustomData * v.texcoord2.zw + (1 - _MaskTexCustomData) * half2(_Mask_USpeed, _Mask_VSpeed) * _Time.y;
                o.uv0 = TRANSFORM_TEX(v.texcoord0, _Texture) + uvOffsetMain;
                o.uv1.xy = TRANSFORM_TEX(v.texcoord0, _NoiseTex) + half2(_NoiseUSpeed, _NoiseVSpeed) * _Time.y;
                o.uv1.zw = TRANSFORM_TEX(v.texcoord0, _Mask) + uvOffsetMask;
                o.uv2.xy = TRANSFORM_TEX(v.texcoord0, _NiuQu) + half2(_DUspeed, _DVsped) * _Time.y;
            #endif

                o.uv2.zw = v.texcoord0;

            #if defined(_VERTOFFSET_ON)
                float2 vertOffsetAnimUV = TRANSFORM_TEX(v.texcoord0, _VertexAnimMap) + float2(_VertexAnimMapFlow_U, _VertexAnimMapFlow_V) * _Time.y; //对顶点偏移进行采样
                float2 vertOffsetMaskUV = TRANSFORM_TEX(v.texcoord0, _VertexAnimMask) + float2(_VertexAnimMapFlowU, _VertexAnimMapFlowV) * _Time.y; //对偏移进行遮罩处理
                float4 animOffsetMap = tex2Dlod(_VertexAnimMap, float4(vertOffsetAnimUV, 1, 1));
                float4 maskOffsetMap = tex2Dlod(_VertexAnimMask, float4(vertOffsetMaskUV, 1, 1));

                half vertAnimOffsetCut = (animOffsetMap.a * (1 - _VertexAnimMapUseR) + sqrt(animOffsetMap.r) * _VertexAnimMapUseR); //透明底或者黑底
                half vertexMaskCut = (maskOffsetMap.a * (1 - _VertexAnimMaskUseR) + sqrt(maskOffsetMap.r) * _VertexAnimMaskUseR);
                half intensityAdd = _VertexAnimOffset_CustomData * v.texcoord3.w + (1 - _VertexAnimOffset_CustomData) * _VertexAnimIntensity;

                half3 vertOffsetNormal = vertAnimOffsetCut * normalize(v.normal.xyz);
                half3 vertOffsetworldPos = _VertexAnimMapVec.xyz * vertAnimOffsetCut;
                half3 vertOffset = lerp(vertOffsetNormal, vertOffsetworldPos, _VertexAnimMapFlow_WorldPos) * intensityAdd;
                // vertOffset *= _VertexAnimIntensity + intensityAdd;
                v.vertex.xyz += lerp(0, vertOffset, vertexMaskCut);
            #endif

		        VertexPositionInputs vertexInput = GetVertexPositionInputs(v.vertex.xyz);
		        VertexNormalInputs normalInput = GetVertexNormalInputs(v.normal.xyz, half4(0, 0, 0, 0));
                o.color = v.vertexColor;
                o.worldNormal = normalInput.normalWS;
                o.worldViewDir = normalize(_WorldSpaceCameraPos.xyz - mul(unity_ObjectToWorld, v.vertex));
                o.pos = vertexInput.positionCS;
                o.worldPos = mul(unity_ObjectToWorld, half4(v.vertex.xyz, 1));

                o.texCustomData = v.texcoord3.xyzw;

			//DECAL
			#if defined(_DECAL_ON)
				float4 positionVS = mul(UNITY_MATRIX_MV, v.vertex);
		        float3 viewRayVS = positionVS.xyz;
		        o.viewRayOS.w = positionVS.z;
		        float4x4 ViewToObjectMatrix = mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V);
		        o.viewRayOS.xyz = mul((float3x3)ViewToObjectMatrix, -viewRayVS).xyz;
		        o.camPosOS = ViewToObjectMatrix._m03_m13_m23;
		        o.screenUV = ComputeScreenPos(o.pos);
			#endif

            #if defined(_FADE_ON)
                //Water
                o.screenPos = ComputeScreenPos(o.pos);
                COMPUTE_EYEDEPTH(o.screenPos.z, v.vertex.xyz);
            #endif

                return o;
            }

			half4 frag(VertexOutput i) : SV_Target
			{
                float diffZ = 1;
            #if defined(_FADE_ON)
                float sceneZ = 0;
                float partZ = max(0, i.screenPos.z - _ProjectionParams.g);

                float sampleDepth = SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, i.screenPos.xy / i.screenPos.z).r;
                sampleDepth = 1.0 / (_ZBufferParams.z * sampleDepth + _ZBufferParams.w);
                sceneZ = max(0, sampleDepth - _ProjectionParams.g);
                diffZ = (sceneZ - partZ) / _DepthFadeFactor;
            #endif

			#if defined(_DECAL_ON)
				i.viewRayOS.xyz *= rcp(i.viewRayOS.w);
			    float2 uv = i.screenUV.xy / i.screenUV.w;
			    float rawDepth = SAMPLE_DEPTH_TEXTURE_LOD(_CameraDepthTexture, sampler_CameraDepthTexture, uv, 0);
			    float depth = LinearEyeDepth(rawDepth, _ZBufferParams);
			    float3 positionOS = i.camPosOS + i.viewRayOS.xyz * depth + float3(0, 0, _DecalOffset);
			  	clip(float3(0.5, 0.5, 0.5) - abs(positionOS.xyz));
			
                half2 uvOffsetMain = half2(_MainTexUSpeed, _MainTexVSpeed) * _Time.y;
                half2 uvOffsetMask = half2(_Mask_USpeed, _Mask_VSpeed) * _Time.y;
                i.uv0 = TRANSFORM_TEX(positionOS.xz + float2(0.5, 0.5), _Texture) + uvOffsetMain;
                i.uv1.xy = TRANSFORM_TEX(positionOS.xz + float2(0.5, 0.5), _NoiseTex) + half2(_NoiseUSpeed, _NoiseVSpeed) * _Time.y;
                i.uv1.zw = TRANSFORM_TEX(positionOS.xz + float2(0.5, 0.5), _Mask) + uvOffsetMask;
                i.uv2.xy = TRANSFORM_TEX(positionOS.xz + float2(0.5, 0.5), _NiuQu) + half2(_DUspeed, _DVsped) * _Time.y;

                _DistortionCustomData = 0;
                _DissCustomData = 0;
                _ValueCustomData = 0;
			#endif	

                half4 _mask_var = tex2D(_Mask, i.uv1.zw);
                half4 mainTex = tex2D(_Texture, i.uv0);
                float3 worldNormal = normalize(i.worldNormal);

            #if defined(_DISTORTION_ON) //打开扭曲
                half distortAdd = _DistortionCustomData * i.texCustomData.z + (1 - _DistortionCustomData) * _DistortionIntensity;
                half4 niuquTex = tex2D(_NiuQu, i.uv2 + half2(_DUspeed, _DVsped) * _Time.g) * distortAdd;
                mainTex = tex2D(_Texture, i.uv0 + niuquTex.rg * half2(_DistortUIns, _DistortVIns) * niuquTex.a);
                _mask_var = tex2D(_Mask, i.uv1.zw + niuquTex.rg * half2(_DistortUIns, _DistortVIns) * niuquTex.a);
                worldNormal += niuquTex.rgb;
            #endif
                half3 finalColor = mainTex.rgb;
                half alpha = 1;
                half maskCut = (_mask_var.a * (1 - _MaskUseR) + sqrt(_mask_var.r) * _MaskUseR) * _MaskIntensity;
                half mainCut = mainTex.a;
                mainCut = _TexuteRorAlpha * mainCut + (1 - _TexuteRorAlpha) * mainTex.a;

            #if defined(_CUTOFF_ON)
                clip(mainCut - _CutOffAlpha);
            #endif

            #if defined(_RIMLIGHT_ON) //打开边缘光
                half3 viewDirection = normalize(i.worldViewDir);
                half fresnelStrength = pow(1.002 - saturate(dot(worldNormal, viewDirection)), _bianyuan);
                fresnelStrength = fresnelStrength * (1 - _RimInverseToggle) + pow((1 - fresnelStrength), 2) * _RimInverseToggle;
                half3 reversCol = mainTex.rgb;
                half3 rimFinCol = fresnelStrength * _ColorOuter.rgb * _RimIntensity + saturate(1 - fresnelStrength) * _ColorInner.rgb * mainTex.rgb * _TextureIntensity;
				finalColor = reversCol * _RimInverseToggle * fresnelStrength + rimFinCol * (1 - _RimInverseToggle);
                alpha *= fresnelStrength * _RimInverseToggle + (1 - _RimInverseToggle) * max(fresnelStrength, _ColorInner.a);
            #endif

                finalColor *= _Color.rgb;
            #if defined(_DISSOLVE_ON) //打开溶解
                half2 uv_dissolve = i.uv1.xy;
                #if defined(_DISTORTION_ON) //打开扭曲
                    uv_dissolve += niuquTex.rg * niuquTex.a;
                #endif
                half4 noiseCol = tex2D(_NoiseTex, uv_dissolve);
                half noiseCut = sqrt(noiseCol.r * noiseCol.a);
                mainCut = (mainTex.a * (1 - _TexuteRorAlpha) + _TexuteRorAlpha * sqrt(mainTex.r)) * step(_BlendMode, 9) + mainTex.a * step(9, _BlendMode);

                half thresholdResult = _DissCustomData * i.texCustomData.x + (1 - _DissCustomData) * _Threshold;
                thresholdResult = thresholdResult * (1 - _ThresholdToggle) + (1 - thresholdResult) * _ThresholdToggle;
                half cutout = (noiseCut - thresholdResult) * _ThresholdToggle + (thresholdResult - noiseCut) * (1 - _ThresholdToggle);
                half blend = smoothstep(_EdgeHardness, 0, cutout - _EdgeLength);
                half colCut = smoothstep(0, _EdgeHardness, cutout);
                finalColor = lerp(finalColor, _EdgeColor * _EdgeIntensity, blend).rgb;
                alpha *= colCut;
            #endif

            #if defined(_FLOW_ON)
                half2 finalFlowUV = 0;
                #if defined(_POLARFLOW_ON)
                    half2 flowUV = GetPolarCoords(i.uv2.zw, _FlowLinearSpeed, _FlowAngularSpeed, 0) + finalFlowUV;
                #else
                    half2 flowUV = TRANSFORM_TEX(i.uv2.zw, _FlowTex) + half2(_FlowUSpeed, _FlowVSpeed) * _Time.y + finalFlowUV;
                #endif

                #if defined(_DISTORTION_ON) //打开扭曲
                    flowUV += niuquTex.rg * niuquTex.a;
                #endif

                half4 flowCol = tex2D(_FlowTex, flowUV);
                half flowMask = sqrt(flowCol.r) * flowCol.a;
                finalColor = finalColor * flowMask * _FlowAddOn + finalColor * (1 - _FlowAddOn);
                mainCut = (mainTex.a * (1 - _TexuteRorAlpha) + _TexuteRorAlpha * sqrt(mainTex.r)) * step(_BlendMode, 9) + mainTex.a * step(9, _BlendMode);
                half3 flowAdd = flowCol.rgb * mainCut * _FlowColor * _FlowStrength * flowMask;

                half4 flowMask_Var = tex2D(_FlowMask, TRANSFORM_TEX(i.uv2.zw, _FlowMask) + half2(_FlowMask_USpeed, _FlowMask_VSpeed) * _Time.y);
                half flowMaskCut = (flowMask_Var.a * (1 - _FlowMaskUseR) + sqrt(flowMask_Var.r) * _FlowMaskUseR) * _FlowMaskIntensity;

                finalColor += flowAdd * flowMaskCut;
                alpha = alpha * flowMask * _FlowAddOn * flowMaskCut + (1 - _FlowAddOn) * alpha;
            #endif

                alpha *= maskCut * mainCut * _Color.a;
                alpha = step(_HorizontalLine, i.worldPos.y) * alpha * _HorizontalClip + alpha * (1 - _HorizontalClip);

                half3 valueOffset = _Value * (1 - _ValueCustomData) + _ValueCustomData * _Value * i.texCustomData.y;
                half3 colorMaskAdd = (1 - _MaskTexColorSwitch) + _MaskTexColorSwitch * _mask_var.rgb;

                finalColor *= alpha * valueOffset * colorMaskAdd;
                
				//float2 fogAtten = ComputeFogAtten(i.worldPos);
                //half2 fogAttenHalf = half2(fogAtten.x, fogAtten.y);
				finalColor.rgb = ApplyFog(finalColor.rgb, 
                    i.worldPos, _EffectFogFactor);
				return half4(finalColor, clamp(alpha * diffZ, 0, 1)) * i.color;
            }
        ENDHLSL

		Pass
		{
            Tags { "LightMode" = "UniversalForward" }
			HLSLPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			ENDHLSL
		}

		Pass
		{
			//剔除不受 扭曲影响Pass，默认用脚本Disable掉
            Tags { "LightMode" = "ScreenDistortion" }
			HLSLPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			ENDHLSL
		}
    }
    FallBack Off
    CustomEditor "RimDistortMaskFlowEditor"
}