using UnityEngine;

public class Bianyuan : MonoBehaviour
{
    public Material mat;

    public Color edgeColor = Color.black; //描边的颜色

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (mat != null)
        {
            mat.SetColor("_EdgeColor", edgeColor);

            Graphics.Blit(source, destination, mat);
        }
    }
}

Shader "Unlit/bianyuan"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}
		_EdgeColor("Edge Color",Color) = (0,0,0,1)
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 100

		Pass
		{
			ZTest Always Cull Off ZWrite Off

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			
			#include "UnityCG.cginc"

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

			sampler2D _MainTex;
			float4 _MainTex_TexelSize;//纹理每个纹素的大小，例如512*512，那就是1/512
			fixed4 _EdgeColor; 
			
			v2f vert (appdata_img v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);

				half2 uv = v.texcoord;

				//计算出当前像素附近的8个像素点，在顶点处理后会经过插值到片元（线性操作），不影响
				o.uv[0] = uv + _MainTex_TexelSize.xy * half2(-1, -1);
				o.uv[1] = uv + _MainTex_TexelSize.xy * half2(0, -1);
				o.uv[2] = uv + _MainTex_TexelSize.xy * half2(1, -1);
				o.uv[3] = uv + _MainTex_TexelSize.xy * half2(-1, 0);
				o.uv[4] = uv + _MainTex_TexelSize.xy * half2(0, 0);
				o.uv[5] = uv + _MainTex_TexelSize.xy * half2(1, 0);
				o.uv[6] = uv + _MainTex_TexelSize.xy * half2(-1, 1);
				o.uv[7] = uv + _MainTex_TexelSize.xy * half2(0, 1);
				o.uv[8] = uv + _MainTex_TexelSize.xy * half2(1, 1);

				return o;
			}
			
			//计算出梯度值，越小表示和附近像素颜色相差越大，边缘可能性大
			half Sobel(v2f i) 
			{ 
				//Sobel边缘检测算子 卷积核
				const half Gx[9] = { -1, -2, -1,                        
									 0,  0,  0,                        
									 1,  2,  1 };    
				const half Gy[9] = { -1,  0,  1,                        
									 -2,  0,  2,                        
									 -1,  0,  1 };    
				half texColor;    
				half edgeX = 0;    
				half edgeY = 0;    
				for (int it = 0; it < 9; it++) 
				{ 
					texColor = Luminance(tex2D(_MainTex, i.uv[it]));        
					edgeX += texColor * Gx[it];        
					edgeY += texColor * Gy[it]; 
				}    
				half edge = 1 - abs(edgeX) - abs(edgeY);  
				return edge; 
			}

			fixed4 frag (v2f i) : SV_Target
			{
				half edge = Sobel(i);
				
				//根据梯度值，看看是否使用的边缘颜色
				fixed4 withEdgeColor = lerp(_EdgeColor, tex2D(_MainTex, i.uv[4]), edge);

				return withEdgeColor;
			}
			ENDCG
		}
	}

	Fallback Off
}

常用的边缘检测算子

如果说在有顶点动画的情况加，我们在常规的Pass修改了模型空间的坐标位置，如果还是使用内置的ShadowCaste去投射阴影的话就会产生错误，因为它用的还是没有修改过的模型顶点信息，所以这就需要自定义这个ShadowCaste的Pass了。

Pass {
	Tags { "LightMode" = "ShadowCaster" }
			
	CGPROGRAM
			
	#pragma vertex vert
	#pragma fragment frag
			
	#pragma multi_compile_shadowcaster
			
	#include "UnityCG.cginc"
			
	float _Magnitude;
	float _Frequency;
	float _InvWaveLength;
	float _Speed;
			
	struct v2f { 
		//定义阴影投射的变量
		V2F_SHADOW_CASTER;
	};
			
	v2f vert(appdata_base v) {
		v2f o;
				
		//和常规Pass一样的顶点信息改变
		float4 offset;
		offset.yzw = float3(0.0, 0.0, 0.0);
		offset.x = sin(_Frequency * _Time.y + v.vertex.z * _InvWaveLength) * _Magnitude;
		v.vertex = v.vertex + offset;

		//直接使用定义好的宏去计算就好了,注意使用v，有vertex和normal
		TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
				
		return o;
	}
			
	fixed4 frag(v2f i) : SV_Target {
		SHADOW_CASTER_FRAGMENT(i) //定义好的宏
	}
	ENDCG
}

Shader "Unity Shaders Book/Chapter 11/Water" {
	Properties {
		_MainTex ("Main Tex", 2D) = "white" {} //水的贴图
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_Magnitude ("Distortion Magnitude", Float) = 1 //幅度
 		_Frequency ("Distortion Frequency", Float) = 1 //频率
 		_InvWaveLength ("Distortion Inverse Wave Length", Float) = 10 //波段
 		_Speed ("Speed", Float) = 0.5  //贴图的uv速度
	}
	SubShader {
		//关闭Unity的动态合并网格，因为合并的话会破坏原模型空间
		Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "DisableBatching"="True"}
		
		Pass {
			Tags { "LightMode"="ForwardBase" }
			
			ZWrite Off
			Blend SrcAlpha OneMinusSrcAlpha
			Cull Off
			
			CGPROGRAM  
			#pragma vertex vert 
			#pragma fragment frag
			
			#include "UnityCG.cginc" 
			
			sampler2D _MainTex;
			float4 _MainTex_ST;
			fixed4 _Color;
			float _Magnitude;
			float _Frequency;
			float _InvWaveLength;
			float _Speed;
			
			struct a2v {
				float4 vertex : POSITION;
				float4 texcoord : TEXCOORD0;
			};
			
			struct v2f {
				float4 pos : SV_POSITION;
				float2 uv : TEXCOORD0;
			};
			
			v2f vert(a2v v) {
				v2f o;
				
				float4 offset;  //顶点的偏移
				offset.yzw = float3(0.0, 0.0, 0.0);//除了x方向需要改变，其它都不用
				offset.x = sin(_Frequency * _Time.y+ v.vertex.z * _InvWaveLength) * _Magnitude;//这个看下面解释
				o.pos = mul(UNITY_MATRIX_MVP, v.vertex + offset);//在模型空间进行偏移后再转换到剪裁空间
				
				o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
				o.uv +=  float2(0.0, _Time.y * _Speed); //使用_Speed控制uv动画的速度
				
				return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
				fixed4 c = tex2D(_MainTex, i.uv);
				c.rgb *= _Color.rgb;
				
				return c;
			} 
			
			ENDCG
		}
	}
	FallBack "Transparent/VertexLit"
}

Quad模型空间在x和z平面上

控制offset.x的偏移是sin(_Frequency * _Time.y+ v.vertex.z * _InvWaveLength) * _Magnitude

_Frequency和时间因子相乘，控制的是波动的速度

_InvWareLength和顶点的z轴相乘，z轴的范围在模型中是定好的，sin(z)的波段是固定的，所以加多一个_InvWareLength相乘后就可以控制波段了。

sin的范围是[-1,1] * _Magnititude就可以影响对x的影响了。

Shader "Unlit/boom"
{
	Properties
	{
		_Color("Color",Color) = (1,1,1,1)
		_MainTex ("Texture", 2D) = "white" {}
		_HorizontalAmount("HA",Float) = 8 //行帧的个数
		_VerticalAmount("VA",Float)  = 8  //有多少行
		_Speed("Speed",Range(1,100)) = 30
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 100
		ZWrite Off
		Blend SrcAlpha OneMinusSrcAlpha

		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 _HorizontalAmount;
			float _VerticalAmount;
			float _Speed;
			fixed4 _Color;
			
			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
			{
				/*float time = floor(_Time.y * _Speed);
				float row_off = 1 / _HorizontalAmount;//每个单位的偏移
				float column_off = 1 / _VerticalAmount;
				float row = floor(time / _HorizontalAmount);
				float column = time - row * _HorizontalAmount;
				float2 uv;//起始位置 + 偏移
				uv.x = i.uv.x / _HorizontalAmount + column_off * column;
				uv.y = i.uv.y / _VerticalAmount - row * row_off;*/
				
				//如果看不懂，看上面好理解点，这里整合了
				float time = floor(_Time.y * _Speed);
				float row = floor(time / _HorizontalAmount);
				float column = time - row * _HorizontalAmount;
				half2 uv = i.uv + half2(column, -row);//column和row都为整数，后面处理Amount后，相当于 colomn * 1 / _HorizontalAmount 对应上面
				uv.x /= _HorizontalAmount;
				uv.y /= _VerticalAmount;
				fixed4 col = tex2D(_MainTex, uv) * _Color;
				return col;
			}
			ENDCG
		}
	}
}

在Unity中，纹理坐标在竖直方向上是由下往上逐渐变大的，所以是-row，将方向由上往下播放。

菲涅尔反射描述的是当光线照射到物体表面上时，一部分发生反射，一部分进入物体内部，发射折射或散射。被反射的光和入射光之间存在一定的比率关系，这个比率关系可以通过菲涅尔等式进行计算。

Schlick菲涅尔近似等式：F_schlick(v,n) = F0+(1 - F0)(1 - v•n)⁵ ，F0是一个反射系数，控制菲涅尔反射的强度，v是视角方向，n是表面法线。

Shader "Unlit/fresnel"
{
    Properties
    {
        _ReflectColor("Color a",Color) = (1,1,1,1)
        _Cubemap("Map",Cube) = "_Skybox"{} //使用天空盒子的立方体纹理
        _FresnelScale("Fresnel",Range(0,1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            #include "Lighting.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float3 worldNormal :TEXCOORD0;
                float4 worldPos : TEXCOORD1;
                float3 reflactDir:TEXCOORD2;
                float3 worldViewDir:TEXCOORD3;
            };

            samplerCUBE _Cubemap;
            fixed4 _ReflectColor;
            float _FresnelScale;
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos);
                o.reflactDir = reflect(normalize(-o.worldViewDir),normalize(o.worldNormal));
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));

                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
                fixed3 diffuse = _LightColor0.rgb * dot(worldNormal, worldLightDir) * 0.5 + 0.5;
                fixed3 relection = texCUBE(_Cubemap, i.reflactDir).rgb * _ReflectColor.rgb;
                //通过菲涅尔等式计算这个比率
                fixed fresnel = _FresnelScale + (1 - _FresnelScale) * pow(1-dot(worldNormal, normalize(i.worldViewDir)), 5);
                fixed3 color = ambient + lerp(diffuse, relection, saturate(fresnel));//插值使用这个比率值
                return fixed4(color,1);
            }
            ENDCG
        }
    }
}