NLDClient-yudde/ProjectNLD/Assets/Code/Shaders/Others/shader_mix.shader

Shader "NLD/Particles/shader_mix"
{
    Properties
    {
        [Header(Option)]
        // [Enum(UnityEngine.Rendering.BlendOp)]  _BlendOp  ("BlendOp", Float) = 0
        [Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
        [Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
        
        [Enum(Off,0,On,1)] _ZWrite("ZWrite", Int) = 0
        [Enum(UnityEngine.Rendering.CompareFunction)]_ZTestMode ("ZTestMode", Float) = 4
        
        [Enum(UnityEngine.Rendering.CullMode)]_CullMode ("CullMode", float) = 0
        
        _AlphaClip("AlphaClip", Range(0, 1.0)) = 0.1
        
        [Header(Custom)]
        [MainTexture] _BaseMap("主贴图", 2D) = "white" {}
        [HDR][MainColor] _BaseColor("主贴图颜色", Color) = (1,1,1,1)
        _BaseColorScale("主贴图颜色强度", Float) = 1
        _UVMoveX("主贴图 UV移动X", Float) = 0
        _UVMoveY("主贴图 UV移动Y", Float) = 0

        [MaterialToggle(_TEX2_ON)] _Toggle2("附加贴图 启用", Float) = 0
        _BaseMap2("附加贴图", 2D) = "white" {}
        [HDR] _BaseColor2("附加贴图 颜色", Color) = (1,1,1,1)
        _BlendProgress("附加贴图 混合进度", Range(0, 1.0)) = 0.5
        _UVMove2X("附加贴图 UV移动X", Float) = 0
        _UVMove2Y("附加贴图 UV移动Y", Float) = 0

        [MaterialToggle(_DISTORTION_ON)] _Toggle3("扭曲 启用", Float) = 0
        _DistortionMap("扭曲贴图", 2D) = "white" {}
        _DistortionMaxStrength("扭曲 强度", Float) = 0.1
        _DistortionStrength("扭曲 强度", Range(-1,1)) = 0
        _DistortionMoveX("扭曲 UV流动X", Float) = 1
        _DistortionMoveY("扭曲 UV流动Y", Float) = 1

        [MaterialToggle(_MASK_ON)] _Toggle4("Alpha遮罩 启用", Float) = 0
        _MaskMap("Alpha遮罩贴图", 2D) = "white" {}
        _MaskStrength("Alpha遮罩 强度", Range(0, 1.0)) = 0.1
        _MaskMoveX("Alpha遮罩 UV流动X", Float) = 1
        _MaskMoveY("Alpha遮罩 UV流动Y", Float) = 1

        [MaterialToggle(_DISSOLVE_ON)] _Toggle5("溶解 启用", Float) = 0
        _DissolveMap("溶解贴图", 2D) = "white" {}
        _DissolveLength("溶解 范围", Range(0, 1.0)) = 0.1
        _DissolveProgress("溶解 进度", Range(0, 1.0)) = 0
        
        [MaterialToggle(_POLAR_ON)] _Toggle6("极坐标 启用", Float) = 0
        _PolarScale("极坐标 缩放", Range(-1, 5)) = 0
        
        [MaterialToggle(_CUSTOMDATA_ON)] _Toggle1("使用粒子 Custom Data", Float) = 0

    }
    SubShader
    {
        Tags
        {
            "RenderType" = "Transparent"
            "Queue"="Transparent"
            "PreviewType" = "Plane"
            "RenderPipeline" = "UniversalPipeline"
        }

        Pass
        {
            Name "Universal Forward"
            Tags
            {
                // none
            }

            Cull [_CullMode]
            ZWrite [_ZWrite]
            ZTest [_ZTestMode]
            // BlendOp [_BlendOp]
            Blend [_BlendSrc] [_BlendDst]
            // AlphaToMask On

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _CUSTOMDATA_OFF _CUSTOMDATA_ON
            #pragma multi_compile _TEX2_OFF _TEX2_ON
            #pragma multi_compile _DISTORTION_OFF _DISTORTION_ON
            #pragma multi_compile _MASK_OFF _MASK_ON
            #pragma multi_compile _DISSOLVE_OFF _DISSOLVE_ON
            #pragma multi_compile _POLAR_OFF _POLAR_ON

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct appdata
            {
                float4 positionOS : POSITION;
                float4 color: COLOR;
                float4 uv : TEXCOORD0;

                #if _CUSTOMDATA_ON
                    float4 customData: TEXCOORD1;
                #endif

                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float4 vColor: COLOR;
                float2 uv : TEXCOORD0;

                #if _CUSTOMDATA_ON
                    float4 customData: TEXCOORD1;
                #endif

                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);

            #if _TEX2_ON
            TEXTURE2D(_BaseMap2);
            SAMPLER(sampler_BaseMap2);
            #endif

            #if _DISTORTION_ON
            TEXTURE2D(_DistortionMap);
            SAMPLER(sampler_DistortionMap);
            #endif

            #if _MASK_ON
            TEXTURE2D(_MaskMap);
            SAMPLER(sampler_MaskMap);
            #endif

            #if _DISSOLVE_ON
            TEXTURE2D(_DissolveMap);
            SAMPLER(sampler_DissolveMap);
            #endif


            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                float4 _BaseColor;
                float _UVMoveX;
                float _UVMoveY;

                #if _TEX2_ON
                float4 _BaseMap2_ST;
                float4 _BaseColor2;
                float _BlendProgress;
                float _UVMove2X;
                float _UVMove2Y;
                #endif

                #if _DISTORTION_ON
                float4 _DistortionMap_ST;
                float _DistortionMaxStrength;
                float _DistortionStrength;
                float _DistortionMoveX;
                float _DistortionMoveY;
                #endif

                #if _MASK_ON
                float4 _MaskMap_ST;
                float _MaskStrength;
                float _MaskMoveX;
                float _MaskMoveY;
                #endif

                #if _DISSOLVE_ON
                float4 _DissolveMap_ST;
                float _DissolveLength;
                float _DissolveProgress;
                #endif

                #if _POLAR_ON
                float _PolarScale;
                #endif

                float _AlphaClip;
            
                float _BaseColorScale;
            CBUFFER_END

            v2f vert(appdata v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
                o.vertex = TransformObjectToHClip(v.positionOS.xyz);
                // o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                o.uv = v.uv;
                o.vColor = v.color * _BaseColor * _BaseColorScale;

                #if _CUSTOMDATA_ON
                    o.customData = v.customData;
                #endif
                return o;
            }

            float4 frag(v2f IN) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN);
                const float time = _TimeParameters.x;

                // float2 inUV = IN.uv;

                
                // 主贴图UV流动
                float2 uv = TRANSFORM_TEX(IN.uv, _BaseMap);
                #if _DISTORTION_ON
                // 扭曲贴图UV流动
                float2 uvDistortion = TRANSFORM_TEX(IN.uv, _DistortionMap);
                uvDistortion.x += time * _DistortionMoveX;
                uvDistortion.y += time * _DistortionMoveY;

                // 扭曲贴图颜色采样
                float4 distortionColor = SAMPLE_TEXTURE2D(_DistortionMap, sampler_DistortionMap, uvDistortion);
                distortionColor = distortionColor * 2 - 1;
                distortionColor *= _DistortionStrength * _DistortionMaxStrength;
                uv += distortionColor.xy;
                #endif



                #if _CUSTOMDATA_ON
                    uv.x += IN.customData.x;
                    uv.y += IN.customData.y;
                #else
                uv.x += time * _UVMoveX;
                uv.y += time * _UVMoveY;
                #endif

                #if _POLAR_ON
                // 极坐标
                float2 centerUV = float2(0.5, 0.5);
                float2 polarUV = uv - centerUV;
                float polar = length(polarUV);
                float2 polarUVN = float2(polar * 2.0, atan2(polarUV.x, polarUV.y) / TWO_PI);
                uv = polarUVN;
                #if _CUSTOMDATA_ON
                    uv.x += IN.customData.w;
                #else
                    uv.x += _PolarScale;
                #endif
                
                #endif

                // 主贴图颜色采样
                float4 col = _BaseMap.Sample(sampler_BaseMap, uv);
                col *= IN.vColor;

                #if _TEX2_ON
                // 附加贴图UV流动
                float2 uv2 = TRANSFORM_TEX(IN.uv, _BaseMap2);
                uv2.x += time * _UVMove2X;
                uv2.y += time * _UVMove2Y;

                // 附加贴图颜色采样
                float4 col2 = SAMPLE_TEXTURE2D(_BaseMap2, sampler_BaseMap2, uv2);
                col2 *= _BaseColor2;
                col2.a *= IN.vColor.a;

                // 颜色混合
                col = lerp(col, col2, _BlendProgress);
                #endif

                #if _DISSOLVE_ON
                float2 uvDissolve = TRANSFORM_TEX(IN.uv, _DissolveMap);
                float4 dissolveColor = SAMPLE_TEXTURE2D(_DissolveMap, sampler_DissolveMap, uvDissolve);
                float dissolve = dissolveColor.r;
                
                #if _CUSTOMDATA_ON
                float dissolveProgress = IN.customData.z;
                #else
                float dissolveProgress = _DissolveProgress;
                #endif
                
                float dissolveLength = min(_DissolveLength, dissolveProgress);
                // 小于最小值的时候，不显示
                if (dissolve < dissolveProgress)
                {
                    discard;
                }
                // 在最小值和最大值之间的时候，显示透明度
                if (dissolve < dissolveLength + dissolveProgress)
                {
                    col.a *= (dissolve - dissolveProgress) / dissolveLength;
                }
                #endif

                #if _MASK_ON
                // 遮罩贴图UV流动
                float2 uvMask = TRANSFORM_TEX(IN.uv, _MaskMap);
                uvMask.x += time * _MaskMoveX;
                uvMask.y += time * _MaskMoveY;

                // 遮罩贴图颜色采样
                float4 maskColor = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, uvMask);
                col.a = lerp(col.a, col.a * maskColor.a, _MaskStrength);
                
                #endif

                if (col.a < _AlphaClip)
                {
                    discard;
                }

                return col;
            }
            ENDHLSL
        }
    }
}