FireShader(Gradient Noise,Voronoi)

Shader代码

 Properties
    {
        _MainTex ("Texture", 2D) = "white" {}

       // _DistorNum("扭曲系数",float)=0.1

        [HDR]_FirCol("火焰颜色",color)=(1,1,1,1)

         FirSpeed("外焰速度",Vector)=(1,1,1,1)
         
          //值越大，火焰的范围就越大
         FirScope("火焰的显示范围",float)=0.1
         //此值越大，火焰的分裂越细
         FirGrade("火焰分散的强度",float)=7.5


         VoronoiSpeed("Voronoi细胞的方向",Vector)=(1,1,1,1)


        //Voroni幂次方此值，细胞越少，裁剪越少，同时返回的白色区域越多，越白（即R,G,B值增多）白色区域乘以像素点，会让该像素点更亮
         VoronoiAmount("Voronoi细胞的系数",float)=1.5

        //细胞经过的地方，颜色混合后通过透明度裁剪，会裁剪掉该部分的像素
         VoronoiScale("Voronoi细胞的多少",float)=3


        
    }
    SubShader
    {
       Tags { "RenderType"="Transparent" }
         //   Tags { "RenderType" = "AlphaTest" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
           

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
           
            float _DistorNum;

            float4 _FirCol;


            


            float4 FirSpeed;
            float FirScope;
            float FirGrade;


            float4 VoronoiSpeed;
            float  VoronoiAmount;
            float  VoronoiScale;



            inline float2 unity_voronoi_noise_randomVector(float2 UV, float offset)
            {
                float2x2 m = float2x2(15.27, 47.63, 99.41, 89.98);
                UV = frac(sin(mul(UV, m)) * 46839.32);
                return float2(sin(UV.y * +offset) * 0.5 + 0.5, cos(UV.x * offset) * 0.5 + 0.5);
            }

            void Unity_Voronoi_float(float2 UV, float AngleOffset, float CellDensity, out float Out)
            {
                float2 g = floor(UV * CellDensity);
                float2 f = frac(UV * CellDensity);
                float t = 8.0;
                float3 res = float3(8.0, 0.0, 0.0);

                for (int y = -1; y <= 1; y++)
                {
                    for (int x = -1; x <= 1; x++)
                    {
                        float2 lattice = float2(x, y);
                        float2 offset = unity_voronoi_noise_randomVector(lattice + g, AngleOffset);
                        float d = distance(lattice + offset, f);
                        if (d < res.x)
                        {
                            res = float3(d, offset.x, offset.y);
                            Out = res.x;
                          
                        }
                    }
                }
            }


            float2 unity_gradientNoise_dir(float2 p)
            {
                p = p % 289;
                float x = (34 * p.x + 1) * p.x % 289 + p.y;
                x = (34 * x + 1) * x % 289;
                x = frac(x / 41) * 2 - 1;
                return normalize(float2(x - floor(x + 0.5), abs(x) - 0.5));
            }

            float unity_gradientNoise(float2 p)
            {
                float2 ip = floor(p);
                float2 fp = frac(p);
                float d00 = dot(unity_gradientNoise_dir(ip), fp);
                float d01 = dot(unity_gradientNoise_dir(ip + float2(0, 1)), fp - float2(0, 1));
                float d10 = dot(unity_gradientNoise_dir(ip + float2(1, 0)), fp - float2(1, 0));
                float d11 = dot(unity_gradientNoise_dir(ip + float2(1, 1)), fp - float2(1, 1));
                fp = fp * fp * fp * (fp * (fp * 6 - 15) + 10);
                return lerp(lerp(d00, d01, fp.y), lerp(d10, d11, fp.y), fp.x);
            }

            void Unity_GradientNoise_float(float2 UV, float Scale, out float Out)
            {
                Out = unity_gradientNoise(UV * Scale) + 0.5;
            }


             float Ret(float a)
            {
                return a <=0.4 ? -1 : 0;
            }

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
              
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {

                 

                 float2 To2 = i.uv + FirSpeed.xy * _Time.y;
                 float GradNoise;
                 Unity_GradientNoise_float(To2, FirGrade, GradNoise);

                 float2 firuv= lerp(i.uv, GradNoise, FirScope);


                 fixed4 fircol = tex2D(_MainTex, firuv);
               
                 


                 float2 To = i.uv + VoronoiSpeed.xy * _Time.y;
                 float Vorone;
                 Unity_Voronoi_float(To, 2, VoronoiScale, Vorone);

                 fixed4 finalcol = pow(Vorone, VoronoiAmount) * GradNoise * fircol * _FirCol;

                 

                 clip(Ret(finalcol.r+ finalcol.g+ finalcol.b));



                return finalcol;
            }
            ENDCG
        }
    }

ShaderGraph