屏幕后期特效：

场景渲染完以后在添加一些特效。
1,引擎渲染后最终的结果是一张图片。

1， void OnRenderImage(RenderTexture sourceTexture, RenderTexture desTexture)
2， Graphics.Blit(sourceTexture, desTexture,mat);
sourceTexture拦截相机渲染出来的图片。
mat : 用哪个材质球重新渲染sourceTexture。
desTexture：更改以后的图片存在这里 重新交给引擎。

2,将图片传递给 shader 进行二次计算。

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "Custom/GaoSi"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}


		_Ambient ("Ambient", float) = 0.001
	}
	SubShader
	{
		// No culling or depth
		Cull Off ZWrite Off ZTest Always

		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;
			};

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


			float   _Ambient;

			fixed4 frag (v2f i) : SV_Target
			{

			   float2  tmpUV =  i.uv ;


			 //  float    ambient = 0.001 ;

				fixed4 col = tex2D(_MainTex, tmpUV);
				//  just invert the colors
				// col = 1 - col;


				fixed4 col2 = tex2D(_MainTex, tmpUV+float2(-_Ambient,0));


				fixed4 col3 = tex2D(_MainTex, tmpUV+float2(0,-_Ambient));

			  	fixed4 col4 = tex2D(_MainTex, tmpUV+float2(_Ambient,0));

			   fixed4 col5 = tex2D(_MainTex, tmpUV+float2(0,_Ambient));



			   col   =  (col + col2 +col3+col4+col5) /5.0 ;


				return col;
			}
			ENDCG
		}
	}
}

生命周期

Blood 血液闪烁特效：

1, 红色光线从两边闪出

圆心(-0.5,0.5) (1.5, 0.5)

2，红色有中间到两边渐变变浓。
通过圆心的距离判别渐变的过程。
Length : 求向量的模长
Lerp： (1-t) A + t * B - - -
Lerp (A,B,T)
Clamp（x, a , b） : 表示将 X 限制在 a 和 B 之间。
Material 更改shader 属性：
graphicMat.SetFloat
graphicMat.SetTexture

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
	Shader "Hidden/Blood"
	{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
		_BloodLength (" length",float) = 0.5
	}
	SubShader
	{
		// No culling or depth
		//Cull Off ZWrite Off ZTest Always
		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;
			};

			v2f vert (appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.uv = v.uv;
				return o;
			}
			
			sampler2D _MainTex;
			float _BloodLength;
			fixed4 frag (v2f i) : SV_Target
			{
			    float2  tmpUV =  i.uv ;
				float  tmpLength = 0 ;
				if(tmpUV.x < 0.5)
				{
				  	   tmpLength  =  length ( tmpUV - float2(-0.5 ,0.5)) ;
				}
				else
				{
				       tmpLength  =  length (float2(1.5 ,0.5)- tmpUV  ) ;
				}
				tmpLength  *= _BloodLength ;
				fixed4 col = tex2D(_MainTex, i.uv);
				col  = lerp(col,fixed4(1,0,0,1) , 1-clamp(tmpLength,0,1) ) ;
				return col;
			}
			ENDCG
		}
	}
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Blood : MonoBehaviour {
	// Use this for initialization
	void Start () {		
	}

    float tmpCount;

	// Update is called once per frame
	void Update () {
        tmpCount += Time.deltaTime*5;
        rangValue =  Mathf.Sin(tmpCount) ;  //  -1   1
        rangValue = 1+(rangValue + 1) * 0.25f  ;   //  0 --0.5     //  1---1.	
	}

    public float rangValue;
    public Material graphicMat;
    void OnRenderImage(RenderTexture sourceTexture, RenderTexture desTexture)
    {
        graphicMat.SetFloat("_BloodLength", rangValue)   
        Graphics.Blit(sourceTexture, desTexture, graphicMat);
    }
}

屏幕特效–波动屏幕

波动方程：
y=Asin(ωx+φ)
φ：决定波形与X轴位置关系或横向移动距离（左加右减）
ω：决定周期（最小正周期T=2π/∣ω∣）
A：决定峰值（即纵向拉伸压缩的倍数）

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "Hidden/Wave"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
		_Arange("Amplitute",float) = 1
		_Frenquncy("Frenquncy",float) = 0.5
		_Speed("Speed",float) = 0.5
	}

	SubShader
	{
		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;
			};


		   float   _Frenquncy ;

			float    _Arange ;

			float   _Speed ;


			v2f vert (appdata v)
			{
				  v2f o;
			      float  timer =  _Time.y *  _Speed ;
				  float  waver  = _Arange* sin(timer +  v.vertex.x *_Frenquncy );
				  v.vertex.y =  v.vertex.y + waver ;
				  o.vertex = UnityObjectToClipPos(v.vertex);
				  o.uv = v.uv;
				  return o;
			}
			
			sampler2D _MainTex;

	


			fixed4 frag (v2f i) : SV_Target
			{
				fixed4 col = tex2D(_MainTex, i.uv);
				// just invert the colors
				//col = 1 - col;
				return col;
			}
			ENDCG
		}
	}
}

1.前言

今天给大家介绍一个非常炫酷的UV流光特效。可以用于UI的Image的图片波动+炫光的效果。
效果使用ShaderForge实现的，原因是ShaderForge可以很方便的导出源码，而ShaderGraph不可以。
ShaderForge虽然对Unity新版本不再支持了，但是这个仓库：ShaderForge，作者兼容了很多新版本的Unity，我们依然还是可以使用。

2.素材

素材1：主图片，用于效果的主体显示和波动颜色

素材2：噪波图，用于干扰主图渲染UV的干扰图，控制显示流动效果

3.UV波动效果

普通的UV波动效果如下图所示：

下面是再ShaderForge中使用节点链接的，逻辑非常简单清晰

4.波动+炫光效果

我们也可以根据自己的需要，给shader添加不同的参数，比如炫光，颜色叠加等。比如看下我加的炫光效果如下：
白色流光：

彩色炫光：

ShaderForge实现：

5.UV流动原理

使用了时间节点Time和自定义参数pannerUV，来控制图片的UV流动，其中噪波图的流动和主图的流动原理一样。详见下图：

6.参数解释

tex1_pannerUV：噪波图的uv流动速度
tex2_pannerUV：主图的uv流动速度，例子中是0，不需要主图流动
disturbance_stronger：噪波图的强度，可以是扰动更剧烈
flow_color：炫光的颜色
t1_stronger：噪波产生的炫光的强度
t2_stronger：主图的亮度

7.Shader源码

最后我们贴出Shader的源码，让大家可以直接使用：

Shader "Shader Forge/uv_flow_pure" {
    Properties {
        _Tex1 ("Tex1", 2D) = "white" {}
        _Tex2 ("Tex2", 2D) = "white" {}
        _tex1_panner_U ("tex1_panner_U", Range(-5, 5)) = 0.1
        _tex1_panner_V ("tex1_panner_V", Range(-5, 5)) = 0.1
        _tex2_panner_U ("tex2_panner_U", Range(-5, 5)) = 0
        _tex2_panner_V ("tex2_panner_V", Range(-5, 5)) = 0
        _disturbance_stronger ("disturbance_stronger", Range(0, 5)) = 0.2
        _flow_color ("flow_color", Color) = (1,1,1,1)
        _t1_stronger ("t1_stronger", Range(0, 10)) = 1
        _t2_stronger ("t2_stronger", Range(0, 10)) = 1
    }
    SubShader {
        Tags {
            "RenderType"="Opaque"
        }
        Pass {
            Name "FORWARD"
            Tags {
                "LightMode"="ForwardBase"
            }
            
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_instancing
            #include "UnityCG.cginc"
            #pragma multi_compile_fwdbase_fullshadows
            #pragma target 3.0
            uniform sampler2D _Tex1; uniform float4 _Tex1_ST;
            uniform sampler2D _Tex2; uniform float4 _Tex2_ST;
            UNITY_INSTANCING_BUFFER_START( Props )
                UNITY_DEFINE_INSTANCED_PROP( float, _tex1_panner_U)
                UNITY_DEFINE_INSTANCED_PROP( float, _disturbance_stronger)
                UNITY_DEFINE_INSTANCED_PROP( float, _t2_stronger)
                UNITY_DEFINE_INSTANCED_PROP( float, _tex1_panner_V)
                UNITY_DEFINE_INSTANCED_PROP( float, _tex2_panner_V)
                UNITY_DEFINE_INSTANCED_PROP( float, _tex2_panner_U)
                UNITY_DEFINE_INSTANCED_PROP( float, _t1_stronger)
                UNITY_DEFINE_INSTANCED_PROP( float4, _flow_color)
            UNITY_INSTANCING_BUFFER_END( Props )
            struct VertexInput {
                UNITY_VERTEX_INPUT_INSTANCE_ID
                float4 vertex : POSITION;
                float2 texcoord0 : TEXCOORD0;
                float4 vertexColor : COLOR;
            };
            struct VertexOutput {
                float4 pos : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                float2 uv0 : TEXCOORD0;
                float4 vertexColor : COLOR;
            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID( v );
                UNITY_TRANSFER_INSTANCE_ID( v, o );
                o.uv0 = v.texcoord0;
                o.vertexColor = v.vertexColor;
                o.pos = UnityObjectToClipPos( v.vertex );
                return o;
            }
            float4 frag(VertexOutput i) : COLOR {
                UNITY_SETUP_INSTANCE_ID( i );
// Lighting:
                float _t1_stronger_var = UNITY_ACCESS_INSTANCED_PROP( Props, _t1_stronger );
                float _tex1_panner_U_var = UNITY_ACCESS_INSTANCED_PROP( Props, _tex1_panner_U );
                float _tex1_panner_V_var = UNITY_ACCESS_INSTANCED_PROP( Props, _tex1_panner_V );
                float4 node_5719 = _Time;
                float2 node_2527 = ((float2(_tex1_panner_U_var,_tex1_panner_V_var)*node_5719.g)+i.uv0); // UV流动
                float4 _Tex1_var = tex2D(_Tex1,TRANSFORM_TEX(node_2527, _Tex1)); // 噪波干扰
                float _disturbance_stronger_var = UNITY_ACCESS_INSTANCED_PROP( Props, _disturbance_stronger );
                float node_6101 = (_Tex1_var.r*_disturbance_stronger_var);
                float4 _flow_color_var = UNITY_ACCESS_INSTANCED_PROP( Props, _flow_color );
                float _tex2_panner_U_var = UNITY_ACCESS_INSTANCED_PROP( Props, _tex2_panner_U );
                float _tex2_panner_V_var = UNITY_ACCESS_INSTANCED_PROP( Props, _tex2_panner_V );
                float4 node_7472 = _Time;
                float2 node_326 = (node_6101+((float2(_tex2_panner_U_var,_tex2_panner_V_var)*node_7472.g)+i.uv0));
                float4 _Tex2_var = tex2D(_Tex2,TRANSFORM_TEX(node_326, _Tex2)); // 叠加效果
                float _t2_stronger_var = UNITY_ACCESS_INSTANCED_PROP( Props, _t2_stronger );
                float3 finalColor = (i.vertexColor.rgb*((_t1_stronger_var*node_6101*_flow_color_var.rgb)+_Tex2_var.rgb)*_t2_stronger_var);
                return fixed4(finalColor,1);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
    CustomEditor "ShaderForgeMaterialInspector"
}

好了，这篇文章就到这里，希望对你有所帮助

  终于可以自己写一些简单的shader特效了，今天用一个并不常用的几何着色器来做一个简单的爆炸，沙化的特效。调节shader参数之后会得到各种好玩的东西。

烟花爆炸

  有初速度，加速度为负的。
  这个还不是很像，可以加上重力加速度以及对各方向的加速度做随机可以让它看起来不那么圆。这个特效用的模型是Unity内置的球，更换一些奇怪的模型并调节加速度和初速度后可以得到一些意想不到的效果。

模型沙化

初速度为0，加速度大于0，还是挺由意思的。

Shader代码

// 模型粒子化效果
Shader "Custom/Particles"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
		_InitSpeed("Init Speed", Float) = 0
		_Acceleration("Acceleration", Float) = 5
        _ContinueTime("Current Time",Int) = 2
        _Color("Color",Color) = (1,1,1,1)
    }
    SubShader
    {
        Pass{
            Tags { "RenderType"="Opaque" }

            CGPROGRAM
            
            #pragma vertex vert
            #pragma geometry geom
            #pragma fragment frag

            sampler2D _MainTex;
            float _InitSpeed;
            float _Acceleration;
            float _ContinueTime;
            fixed4 _Color;

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

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

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

            v2g vert(a2v v){
                v2g o;
                o.vertex = v.vertex;
                o.uv = v.uv;
                return o;
            }

            // 定义输出顶点的最大数量
            [maxvertexcount(1)]
            void geom(triangle v2g IN[3], inout PointStream<g2f> pointStream){
                g2f o;
                float3 v1 = IN[1].vertex - IN[0].vertex;
                float3 v2 = IN[2].vertex - IN[0].vertex;

                float3 normal = normalize(cross(v1,v2));
                float3 pos = (IN[0].vertex + IN[1].vertex + IN[2].vertex) / 3;

                float time = _Time.y % _ContinueTime;
                pos += normal * (_InitSpeed * time + 0.5 * _Acceleration * pow(time, 2));

                o.vertex = UnityObjectToClipPos(pos);

                o.uv = (IN[0].uv + IN[1].uv + IN[2].uv) / 3;

                pointStream.Append(o);
            }

            fixed4 frag (g2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex, i.uv) * _Color;
                return color;
            }

            ENDCG
        }
        
    }
    FallBack "Diffuse"
}