Unity Shader开发入门 (DLC)

Shader "Unlit/SequentialFrameAnimation"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //图集行列
        _Rows("Rows", int) = 8
        _Columns("Columns", int) = 8
        //切换动画速度变量
        _Speed("Speed", float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float _Rows;
            float _Columns;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //得到当前帧 利用时间变量计算
                float frameIndex = floor(_Time.y * _Speed) % (_Rows * _Columns);
                //小格子（小图片）采样时的起始位置计算
                //除以对应的行和列 目的是将行列值 转换到 0~1的坐标范围内
                //1 - (floor(frameIndex / _Columns) + 1)/_Rows
                //  +1 是因为把格子左上角转换为格子左下角(想拿到这行的底边的 UV 坐标，而不是顶边)
                //  1- 因为UV坐标采样时从左下角进行采样的
                float2 frameUV = float2(frameIndex % _Columns / _Columns, 1 - (floor(frameIndex / _Columns) + 1)/_Rows);
                //得到uv缩放比例 相当于从0~1大图 隐射到一个 0~1/n的一个小图中
                float2 size = float2(1/_Columns, 1/_Rows);
                //计算最终的uv采样坐标信息
                //*size 相当于把0~1范围 缩放到了 0~1/8范围
                //+frameUV 相当于把起始的采样位置 移动到了 对应帧小格子的起始位置
                float2 uv = i.uv * size + frameUV;
                //最终采样颜色
                return tex2D(_MainTex, uv);
            }
            ENDCG
        }
    }
}

Shader "Unlit/ScrollingBackground"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //水平和竖直的滚动速度
        _ScrollSpeedU("ScrollSpeedU", float) = 0.5
        _ScrollSpeedV("ScrollSpeedV", float) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
          

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float _ScrollSpeedU;
            float _ScrollSpeedV;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //利用时间 来计算UV的偏移 因为时间一直在变化 所以最终的uv坐标也不停地在变 
                float2 scrollUV = frac(i.uv + float2(_Time.y * _ScrollSpeedU, _Time.y * _ScrollSpeedV));
                return tex2D(_MainTex, scrollUV);
            }
            ENDCG
        }
    }
}

Shader "Unlit/2DWater"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //波动幅度
        _WaveAmplitude("WaveAmplitude", Float) = 1
        //波动频率
        _WaveFrequency("WaveFrequency", Float) = 1
        //波长的倒数
        _InvWaveLength("InvWaveLength", Float) = 1

        //纹理变化速度
        _Speed("Speed", Float) = 1
    }
    SubShader
    {
        //透明Shader相关渲染标签 + 关闭批处理标签
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _Color;
            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移(请注意，这里的方向得看模型空间自身方向的)
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                o.vertex = UnityObjectToClipPos(v.vertex + offset);

                o.uv = v.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;

                o.uv += float2(0, _Time.y *_Speed );

                return o;
            }

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

Shader "Unlit/Lesson95_Billboarding"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //用于控制垂直广告牌和全向广告牌的变化
        _VerticalBillboarding("VerticalBillboarding", Range(0,1)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha
            Cull Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _Color;
            float _VerticalBillboarding;

            v2f vert (appdata_base v)
            {
                v2f o;
                //新坐标系的中心点（默认我们还是使用的模型空间原定，这里的center可以实现在非轴心点进行程序化旋转，下文会提到）
                float3 center = float3(0,0,0);
                //计算Z轴（normal）
                float3 cameraInObjectPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
                //得到Z轴对应的向量
                float3 normalDir = cameraInObjectPos - center;
                //相当于把y往下压，如果_VerticalBillboarding是0 就代表把我们Z轴压到了xz平面 如果是1 那么就是正常的视角方向
                normalDir.y *= _VerticalBillboarding;
                //单位化Z轴
                normalDir = normalize(normalDir);
                //模型空间下的Y轴正方向 作为它的 old up
                //为了避免z轴和010重合 ，因为重合后再计算叉乘 可能会得到0向量
                float3 upDir = normalDir.y > 0.999 ? float3(0,0,1) : float3(0,1,0);
                //利用叉乘计算X轴（right）
                float3 rightDir = normalize(cross(upDir, normalDir));
                //去计算我们的Y轴 也就是newup
                upDir = normalize(cross(normalDir, rightDir));

                //得到顶点相对于新坐标系中心点的偏移位置
                float3 centerOffset = v.vertex.xyz - center;
                //利用3个轴向进行最终的顶点位置的计算
                float3 newVertexPos = center + rightDir * centerOffset.x + upDir * centerOffset.y + normalDir * centerOffset.z;
                //把新顶点转换到裁剪空间
                o.vertex = UnityObjectToClipPos(float4(newVertexPos, 1));

                //uv坐标偏移缩放
                o.uv = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;

                return o;
            }

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

MeshFilter meshFilter = GetComponent<MeshFilter>();
if (meshFilter != null)
{
    Mesh mesh = meshFilter.mesh;
    Vector3[] vertices = mesh.vertices;
    Color[] colors = new Color[vertices.Length];

    for (int i = 0; i < vertices.Length; i++)
    {
        // 将模型空间位置存储在顶点颜色中
        colors[i] = new Color(vertices[i].x, vertices[i].y, vertices[i].z, 1);
    }

    mesh.colors = colors;
}

Shader "Unlit/Lesson97"
{
     Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //波动幅度
        _WaveAmplitude("WaveAmplitude", Float) = 1
        //波动频率
        _WaveFrequency("WaveFrequency", Float) = 1
        //波长的倒数
        _InvWaveLength("InvWaveLength", Float) = 1

        //纹理变化速度
        _Speed("Speed", Float) = 1
    }
    SubShader
    {
        //透明Shader相关渲染标签 + 关闭批处理标签
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _Color;
            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                o.vertex = UnityObjectToClipPos(v.vertex + offset);

                o.uv = v.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;

                o.uv += float2(0, _Time.y *_Speed );

                return o;
            }

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

        //该注释主要用于进行阴影投影 主要是用来计算阴影映射纹理的
        Pass{
            Tags{"LightMode" = "ShadowCaster"}
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            //  该编译指令时告诉Unity编译器生成多个着色器变体
            //  用于支持不同类型的阴影（SM，SSSM等等）
            //  可以确保着色器能够在所有可能的阴影投射模式下正确渲染
            #pragma multi_compile_shadowcaster
            //  其中包含了关键的阴影计算相关的宏
            #include "UnityCG.cginc"

            struct v2f{
                //顶点到片元着色器阴影投射结构体数据宏
                //这个宏定义了一些标准的成员变量
                //这些变量用于在阴影投射路径中传递顶点数据到片元着色器
                //我们主要在结构体中使用
                V2F_SHADOW_CASTER;
            };

            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;

            v2f vert(appdata_base v)
            {
                v2f data;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                //需要进行顶点偏移位置的修改
                //直接在模型空间下顶点坐标进行计算即可
                v.vertex = v.vertex + offset;
                //o.vertex = UnityObjectToClipPos(v.vertex + offset);

                //转移阴影投射器法线偏移宏
                //用于在顶点着色器中计算和传递阴影投射所需的变量
                //主要做了
                //2-2-1.将对象空间的顶点位置转换为裁剪空间的位置
                //2-2-2.考虑法线偏移，以减轻阴影失真问题，尤其是在处理自阴影时
                //2-2-3.传递顶点的投影空间位置，用于后续的阴影计算
                //我们主要在顶点着色器中使用
                TRANSFER_SHADOW_CASTER_NORMALOFFSET(data);
                return data;
            }

            float4 frag(v2f i):SV_Target
            {
                //阴影投射片元宏
                //将深度值写入到阴影映射纹理中
                //我们主要在片元着色器中使用
                SHADOW_CASTER_FRAGMENT(i);
            }

            ENDCG
        }
    }
    Fallback "VertexLit"
}

Mesh Renderer(网格渲染器)

  └── Mesh(网格) ―― MeshFilter(网格过滤器组件进行关联)

        └── Geometry Data(几何数据)

  └── Material(材质)

        └── Shader(着色器)

        └── Properties(属性：颜色、纹理等 ―― 在Shader中决定哪些属性暴露在材质上)

Skinned Mesh Renderer(蒙皮网格渲染器)

  └── Mesh(网格)

        └── Geometry Data(几何数据)

  └── Bones & Weights(骨骼与权重)

  └── Material(材质)

        └── Shader(着色器)

        └── Properties(属性：颜色、纹理等 ―― 在Shader中决定哪些属性暴露在材质上)

private Material material;
public Color color;
[Range(0,1)]
public float fresnelScale;

private void Start() {
    //获取对象的渲染器
    Renderer renderer = GetComponent<Renderer>();
    if(renderer != null)
    {
        //sharedMaterial和material的区别
        //sharedMaterial:一个是改一个都变
        //material:一个是改一个不会影响其它使用相同材质球的对象
        //得到主材质球
        material = renderer.material;//renderer.sharedMaterial;
        //得到所有的材质球
        Material[] materials = renderer.sharedMaterials; //renderer.materials;
        //修改颜色
        material.color = color;
        //修改主纹理
        material.mainTexture = Resources.Load<Texture2D>("路径");

        if(material.HasColor("_Color"))
        {
            material.SetColor("_Color", color);
            print(material.GetColor("_Color"));
        }
            

        if(material.HasFloat("_FresnelScale"))
            material.SetFloat("_FresnelScale", fresnelScale);

        //修改渲染队列
        material.renderQueue = 2000;

        //修改材质球使用的shader
        material.shader = Shader.Find("Unlit/Lesson80_Fresnel");

        material.SetTextureOffset("_MainTex", new Vector2(0.5f, 0.5f));
        material.SetTextureScale("_MainTex", new Vector2(0.5f, 0.5f));
}

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

[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class PostEffectBase : MonoBehaviour
{
    //屏幕后处理效果会使用的Shader
    public Shader shader;
    //一个用于动态创建出来的材质球 就不用再工程中手动创建了
    private Material _material;

    protected virtual void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //判断这个材质球是否为空 如果不为空 就证明这个shader能用来处理屏幕后处理效果
        if (material != null)
            Graphics.Blit(source, destination, material);
        else//如果为空 就不用处理后处理效果了 直接显示原画面就可以了
            Graphics.Blit(source, destination);
    }

    protected Material material
    {
        get
        {
            //如果shader 没有 或者有但是不支持当前平台
            if (shader == null || !shader.isSupported)
                return null;
            else
            {
                //避免每次调用属性都去new材质球
                //如果之前new过了，并且shader也没有变化
                //那就不用new了 直接返回使用即可
                if (_material != null && _material.shader == shader)
                    return _material;
                //除非材质球是空的 或者shader变化了 才会走下面的逻辑

                //用支持的shader动态创建一个材质球 用于渲染
                _material = new Material(shader);
                //不希望材质球被保存下来 因此我们家一个标识
                _material.hideFlags = HideFlags.DontSave;
                return _material;
            }
        }
    }
}

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

[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class PostEffectBase : MonoBehaviour
{
    //屏幕后处理效果会使用的Shader
    public Shader shader;
    //一个用于动态创建出来的材质球 就不用再工程中手动创建了
    private Material _material;

    protected virtual void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //在进行渲染之前 先更新属性 在子类中重写即可
        UpdateProperty();

        //判断这个材质球是否为空 如果不为空 就证明这个shader能用来处理屏幕后处理效果
        if (material != null)
            Graphics.Blit(source, destination, material);
        else//如果为空 就不用处理后处理效果了 直接显示原画面就可以了
            Graphics.Blit(source, destination);
    }

    /// <summary>
    /// 更新材质球属性
    /// </summary>
    protected virtual void UpdateProperty()
    {

    }

    protected Material material
    {
        get
        {
            //如果shader 没有 或者有但是不支持当前平台
            if (shader == null || !shader.isSupported)
                return null;
            else
            {
                //避免每次调用属性都去new材质球
                //如果之前new过了，并且shader也没有变化
                //那就不用new了 直接返回使用即可
                if (_material != null && _material.shader == shader)
                    return _material;
                //除非材质球是空的 或者shader变化了 才会走下面的逻辑

                //用支持的shader动态创建一个材质球 用于渲染
                _material = new Material(shader);
                //不希望材质球被保存下来 因此我们家一个标识
                _material.hideFlags = HideFlags.DontSave;
                return _material;
            }
        }
    }
}

Shader "Unlit/BrightnessSaturationContrast"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //亮度变量
        _Brightness("Brightness", Float) = 1
        //饱和度变量
        _Saturation("Saturation", Float) = 1
        //对比度变量
        _Contrast("Contrast", Float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            ZTest Always
            Cull Off
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            half _Brightness;
            half _Saturation;
            half _Contrast;

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

            fixed4 frag (v2f i) : SV_Target
            {
                //从捕获的主纹理中采样 
                fixed4 renderTexColor = tex2D(_MainTex, i.uv);

                //亮度计算
                fixed3 finalColor = renderTexColor.rgb * _Brightness;

                //饱和度计算
                fixed L = 0.2126*finalColor.r + 0.7152*finalColor.g + 0.722*finalColor.b;
                fixed3 LColor = fixed3(L,L,L);
                finalColor = lerp(LColor, finalColor, _Saturation);

                //对比度计算
                fixed3 avgColor = fixed3(0.5, 0.5, 0.5);
                finalColor = lerp(avgColor, finalColor, _Contrast);

                return fixed4(finalColor.rgb, 1);
            }
            ENDCG
        }
    }
    Fallback off
}

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

public class Lesson103_BrightnessSaturationContrast : PostEffectBase
{
    [Range(0,5)]
    public float Brightness = 1;
    [Range(0, 5)]
    public float Saturation = 1;
    [Range(0, 5)]
    public float Contrast = 1;

    /// <summary>
    /// 更新相关属性
    /// </summary>
    protected override void UpdateProperty()
    {
        if (material != null)
        {
            material.SetFloat("_Brightness", Brightness);
            material.SetFloat("_Saturation", Saturation);
            material.SetFloat("_Contrast", Contrast);
        }
    }
}

Shader "Unlit/Lesson104_EdgeDetection"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //边缘线的颜色
        _EdgeColor("EdgeColor", Color) = (0,0,0,0)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            ZTest Always
            Cull Off
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct v2f
            {
                //用于存储9个像素uv坐标的变量
                half2 uv[9] : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            //Unity内置纹素变量
            half4 _MainTex_TexelSize;
            fixed4 _EdgeColor;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                //当前顶点的纹理坐标
                half2 uv = v.texcoord;
                //去对9个像素的uv坐标进行计算
                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;
            }

            //计算颜色的灰度值
            fixed calcLuminance(fixed4 color)
            {
                return 0.2126*color.r + 0.7152*color.g + 0.0722*color.b;
            }

            //Sobel算子相关的卷积计算
            half Sobel(v2f o)
            {
                //Sobel算子对应的两个卷积核
                half Gx[9] = {-1, -2, -1,
                               0,  0,  0,
                               1,  2,  1};
                half Gy[9] = {-1, 0, 1,
                              -2, 0, 2,
                              -1, 0, 1};
                half L;//灰度值
                half edgeX = 0;//水平方向梯度值
                half edgeY = 0;//数值方向梯度值
                for (int i = 0; i < 9; i++)
                {
                    //采样颜色后 计算灰度值 并记录下来
                    L = calcLuminance(tex2D(_MainTex, o.uv[i]));
                    edgeX += L * Gx[i];
                    edgeY += L * Gy[i];
                }
                //最终的一个该像素的梯度值
                //half G = abs(edgeX) + abs(edgeY);
                return abs(edgeX) + abs(edgeY);
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //利用索贝尔算子计算梯度值
                half edge = Sobel(i);
                //利用计算出来的梯度值在原始颜色 和边缘线颜色之间进行插值
                fixed4 color = lerp(tex2D(_MainTex, i.uv[4]), _EdgeColor, edge);
                return color;
            }

            ENDCG
        }
    }

    Fallback Off
}

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

public class Lesson104_EdgeDetection : PostEffectBase
{
    public Color EdgeColor;

    protected override void UpdateProperty() 
    {
        if(material != null)
        {
            material.SetColor("_EdgeColor", EdgeColor);
        }
    }
}

Shader "Unlit/EdgeDetection"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //边缘线的颜色
        _EdgeColor("EdgeColor", Color) = (0,0,0,0)
        //背景颜色程度 1为纯色 0为原始颜色
        _BackgroundExtent("BackgroundExtent", Range(0,1)) = 0
        //背景颜色
        _BackgroundColor("BackgroundColor", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            ZTest Always
            Cull Off
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct v2f
            {
                //用于存储9个像素uv坐标的变量
                half2 uv[9] : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            //Unity内置纹素变量
            half4 _MainTex_TexelSize;
            fixed4 _EdgeColor;
            fixed _BackgroundExtent;
            fixed4 _BackgroundColor;


            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                //当前顶点的纹理坐标
                half2 uv = v.texcoord;
                //去对9个像素的uv坐标进行计算
                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;
            }

            //计算颜色的灰度值
            fixed calcLuminance(fixed4 color)
            {
                return 0.2126*color.r + 0.7152*color.g + 0.0722*color.b;
            }

            //Sobel算子相关的卷积计算
            half Sobel(v2f o)
            {
                //Sobel算子对应的两个卷积核
                half Gx[9] = {-1, -2, -1,
                               0,  0,  0,
                               1,  2,  1};
                half Gy[9] = {-1, 0, 1,
                              -2, 0, 2,
                              -1, 0, 1};
                half L;//灰度值
                half edgeX = 0;//水平方向梯度值
                half edgeY = 0;//数值方向梯度值
                for (int i = 0; i < 9; i++)
                {
                    //采样颜色后 计算灰度值 并记录下来
                    L = calcLuminance(tex2D(_MainTex, o.uv[i]));
                    edgeX += L * Gx[i];
                    edgeY += L * Gy[i];
                }
                //最终的一个该像素的梯度值
                //half G = abs(edgeX) + abs(edgeY);
                return abs(edgeX) + abs(edgeY);
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //利用索贝尔算子计算梯度值
                half edge = Sobel(i);
                //利用计算出来的梯度值在原始颜色 和边缘线颜色之间进行插值
                fixed4 withEdgeColor = lerp(tex2D(_MainTex, i.uv[4]), _EdgeColor, edge);
                //纯色上描边
                fixed4 onlyEdgeColor = lerp(_BackgroundColor, _EdgeColor, edge);
                //通过程度变量 去控制 是纯色描边 还是 原始颜色描边 在两者之间 进行过渡
                return lerp(withEdgeColor, onlyEdgeColor, _BackgroundExtent);
            }

            ENDCG
        }
    }

    Fallback Off
}

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

public class EdgeDetection : PostEffectBase
{
    public Color EdgeColor;
    public Color BackgroundColor;
    [Range(0,1)]
    public float BackgroundExtent;

    protected override void UpdateProperty() 
    {
        if(material != null)
        {
            material.SetColor("_EdgeColor", EdgeColor);
            material.SetColor("_BackgroundColor", BackgroundColor);
            material.SetFloat("_BackgroundExtent", BackgroundExtent);
        }
    }
}

Shader "Unlit/GaussianBlur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        //用于包裹共用代码 在之后的多个Pass当中都可以使用的代码
        CGINCLUDE

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        //纹素 x=1/宽  y=1/高
        half4 _MainTex_TexelSize;

        struct v2f
        {
            //5个像素的uv坐标偏移
            half2 uv[5] : TEXCOORD0;
            //顶点在裁剪空间下坐标
            float4 vertex : SV_POSITION;
        };

        //片元着色器函数
        //两个Pass可以使用同一个 我们把里面的逻辑写的通用即可
        fixed4 fragBlur(v2f i):SV_Target
        {
            //卷积运算
            //卷积核 其中的三个数 因为只有这三个数 没有必要声明为5个单位的卷积核
            float weight[3] = {0.4026, 0.2442, 0.0545};
            //先计算当前像素点
            fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];

            //去计算左右偏移1个单位的 和 左右偏移两个单位的 对位相乘 累加
            for (int it = 1; it < 3; it++)
            {
                //要和右元素相乘
                sum += tex2D(_MainTex, i.uv[it*2 - 1]).rgb * weight[it];
                //和左元素相乘
                sum += tex2D(_MainTex, i.uv[it*2]).rgb * weight[it];
            }

            return fixed4(sum, 1);
        }

        ENDCG

        Tags { "RenderType"="Opaque" }

        ZTest Always
        Cull Off
        ZWrite Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vertBlurHorizontal
            #pragma fragment fragBlur

            //水平方向的 顶点着色器函数
            v2f vertBlurHorizontal(appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);

                //5个像素的uv偏移
                half2 uv = v.texcoord;

                //去进行5个像素 水平位置的偏移获取
                o.uv[0] = uv;
                o.uv[1] = uv + half2(_MainTex_TexelSize.x*1, 0);
                o.uv[2] = uv - half2(_MainTex_TexelSize.x*1, 0);
                o.uv[3] = uv + half2(_MainTex_TexelSize.x*2, 0);
                o.uv[4] = uv - half2(_MainTex_TexelSize.x*2, 0);

                return o;
            }
            ENDCG
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vertBlurVertical
            #pragma fragment fragBlur

            //竖直方向的 顶点着色器函数
            v2f vertBlurVertical(appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);

                //5个像素的uv偏移
                half2 uv = v.texcoord;

                //去进行5个像素 水平位置的偏移获取
                o.uv[0] = uv;
                o.uv[1] = uv + half2(0, _MainTex_TexelSize.x*1);
                o.uv[2] = uv - half2(0, _MainTex_TexelSize.x*1);
                o.uv[3] = uv + half2(0, _MainTex_TexelSize.x*2);
                o.uv[4] = uv - half2(0, _MainTex_TexelSize.x*2);

                return o;
            }
            ENDCG
        }
    }

    Fallback Off
}

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

public class Lesson106_GaussianBlur : PostEffectBase
{
    protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //base.OnRenderImage(source, destination);
        if (material != null)
        {
            //准备一个缓存区
            RenderTexture buffer = RenderTexture.GetTemporary(source.width, source.height, 0);
            //因为我们需要用两个Pass 处理图像两次 
            //进行第一次 水平卷积计算
            Graphics.Blit(source, buffer, material, 0); //Color1
            //进行第二次 垂直卷积计算
            Graphics.Blit(buffer, destination, material, 1);//在Color1的基础上乘上Color2 得到最终的高斯模糊计算结果
            //释放缓存区
            RenderTexture.ReleaseTemporary(buffer);
        }
        else
            Graphics.Blit(source, destination);
    }
}

Shader "Unlit/GaussianBlur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSpread("BlurSpread", Float) = 1
    }
    SubShader
    {
        //用于包裹共用代码 在之后的多个Pass当中都可以使用的代码
        CGINCLUDE

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        //纹素 x=1/宽  y=1/高
        half4 _MainTex_TexelSize;
        //纹理偏移间隔单位
        float _BlurSpread;

        struct v2f
        {
            //5个像素的uv坐标偏移
            half2 uv[5] : TEXCOORD0;
            //顶点在裁剪空间下坐标
            float4 vertex : SV_POSITION;
        };

        //片元着色器函数
        //两个Pass可以使用同一个 我们把里面的逻辑写的通用即可
        fixed4 fragBlur(v2f i):SV_Target
        {
            //卷积运算
            //卷积核 其中的三个数 因为只有这三个数 没有必要声明为5个单位的卷积核
            float weight[3] = {0.4026, 0.2442, 0.0545};
            //先计算当前像素点
            fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];

            //去计算左右偏移1个单位的 和 左右偏移两个单位的 对位相乘 累加
            for (int it = 1; it < 3; it++)
            {
                //要和右元素相乘
                sum += tex2D(_MainTex, i.uv[it*2 - 1]).rgb * weight[it];
                //和左元素相乘
                sum += tex2D(_MainTex, i.uv[it*2]).rgb * weight[it];
            }

            return fixed4(sum, 1);
        }

        ENDCG

        Tags { "RenderType"="Opaque" }

        ZTest Always
        Cull Off
        ZWrite Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vertBlurHorizontal
            #pragma fragment fragBlur

            //水平方向的 顶点着色器函数
            v2f vertBlurHorizontal(appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);

                //5个像素的uv偏移
                half2 uv = v.texcoord;

                //去进行5个像素 水平位置的偏移获取
                o.uv[0] = uv;
                o.uv[1] = uv + half2(_MainTex_TexelSize.x*1, 0)*_BlurSpread;
                o.uv[2] = uv - half2(_MainTex_TexelSize.x*1, 0)*_BlurSpread;
                o.uv[3] = uv + half2(_MainTex_TexelSize.x*2, 0)*_BlurSpread;
                o.uv[4] = uv - half2(_MainTex_TexelSize.x*2, 0)*_BlurSpread;

                return o;
            }
            ENDCG
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vertBlurVertical
            #pragma fragment fragBlur

            //竖直方向的 顶点着色器函数
            v2f vertBlurVertical(appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);

                //5个像素的uv偏移
                half2 uv = v.texcoord;

                //去进行5个像素 水平位置的偏移获取
                o.uv[0] = uv;
                o.uv[1] = uv + half2(0, _MainTex_TexelSize.x*1)*_BlurSpread;
                o.uv[2] = uv - half2(0, _MainTex_TexelSize.x*1)*_BlurSpread;
                o.uv[3] = uv + half2(0, _MainTex_TexelSize.x*2)*_BlurSpread;
                o.uv[4] = uv - half2(0, _MainTex_TexelSize.x*2)*_BlurSpread;

                return o;
            }
            ENDCG
        }
    }

    Fallback Off
}

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

public class GaussianBlur : PostEffectBase
{
    [Range(1,8)]
    public int downSample = 1;
    [Range(1,16)]
    public int iterations = 1;
    [Range(0,3)]
    public float blurSpread = 0.6f;

    protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //base.OnRenderImage(source, destination);
        if (material != null)
        {
            int rtW = source.width / downSample;
            int rtH = source.height / downSample;

            //准备一个缓存区
            RenderTexture buffer = RenderTexture.GetTemporary(rtW, rtH, 0);
            //采用双线性过滤模式来缩放 可以让缩放效果更平滑
            buffer.filterMode = FilterMode.Bilinear;
            //直接缩放写入到缓存纹理中
            Graphics.Blit(source, buffer);
            //在使用材质球之前设置 模糊半径属性
            //material.SetFloat("_BlurSpread", blurSpread);

            //多次去执行 高斯模糊逻辑
            for (int i = 0; i < iterations; i++)
            {
                //如果想要模糊半径影响模糊想过更强烈 更平滑
                //一般可以在我们的迭代中进行设置 相当于每次迭代处理高斯模糊时 都在增加我们的间隔距离
                material.SetFloat("_BlurSpread", 1 + i * blurSpread);

                //又声明一个新的缓冲区
                RenderTexture buffer1 = RenderTexture.GetTemporary(rtW, rtH, 0);

                //因为我们需要用两个Pass 处理图像两次 
                //进行第一次 水平卷积计算
                Graphics.Blit(buffer, buffer1, material, 0); //Color1
                //这时 关键内容都在buffer1中 buffer没用了 释放掉
                RenderTexture.ReleaseTemporary(buffer);

                buffer = buffer1;
                buffer1 = RenderTexture.GetTemporary(rtW, rtH, 0);
                //进行第二次 垂直卷积计算
                Graphics.Blit(buffer, buffer1, material, 1);//在Color1的基础上乘上Color2 得到最终的高斯模糊计算结果
                                                                //释放缓存区
                RenderTexture.ReleaseTemporary(buffer);
                //buffer和buffer1指向的都是这一次高斯模糊处理的结果
                buffer = buffer1;
            }
            //在for循环中得到最终的模糊结果 然后写入到目标纹理中
            Graphics.Blit(buffer, destination);
            //释放掉缓存区
            RenderTexture.ReleaseTemporary(buffer);
        }
        else
            Graphics.Blit(source, destination);
    }
}

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

public class GaussianBlur : PostEffectBase {
    [Range(1, 8)] public int downsample = 1;
    [Range(1, 32)] public int iterations = 1;//迭代次数
    [Range(0,3)]
    public float blurSpread = 0.6f;


    protected override void OnRenderImage(RenderTexture source, RenderTexture destination) {
        //base.OnRenderImage(source, destination);
        if (material != null) {
            //准备一个缓存区
            RenderTexture buffer = RenderTexture.GetTemporary(source.width / downsample, source.height / downsample, 0);
            buffer.filterMode = FilterMode.Bilinear;//双线性缩放，这样有插值，不会离散的太离谱

            //缩放写入纹理缓存
            Graphics.Blit(source, buffer);
            for (int i = 0; i < iterations; i++) {
                //如果想要模糊半径影响模糊想过更强烈 更平滑
                //一般可以在我们的迭代中进行设置 相当于每次迭代处理高斯模糊时 都在增加我们的间隔距离
                material.SetFloat("_BlurSpread", 1 + i * blurSpread);
                //新缓冲区
                RenderTexture buffer1 = RenderTexture.GetTemporary(source.width / downsample, source.height / downsample, 0);


                //进行第一次 水平卷积计算
                Graphics.Blit(buffer, buffer1, material, 0);//Color1
                //进行第二次 垂直卷积计算
                Graphics.Blit(buffer1, buffer, material, 1);//在Color1的基础上乘上Color2 得到最终的高斯模糊计算结果
                RenderTexture.ReleaseTemporary(buffer1);
            }

            Graphics.Blit(buffer, destination);

            //释放缓存区
            RenderTexture.ReleaseTemporary(buffer);
        }

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

Shader "Unlit/Lesson108_Bloom"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //用于存储亮度纹理模糊后的结果
        _Bloom("Bloom", 2D) = ""{}
        //亮度阈值 控制亮度纹理 亮度区域的
        _LuminanceThreshold("LuminanceThreshold", Float) = 0.5
        //模糊半径
        _BlurSize("BlurSize", Float) = 1
    }
    SubShader
    {
        CGINCLUDE
        #include "UnityCG.cginc"

        sampler2D _MainTex;
        half4 _MainTex_TexelSize;
        sampler2D _Bloom;
        float _LuminanceThreshold;
        float _BlurSize;

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

        //计算颜色的亮度值（灰度值）
        fixed luminance(fixed4 color)
        {
            return 0.2125*color.r + 0.7154*color.g + 0.0721*color.b;
        }

        ENDCG

        ZTest Always
        Cull Off
        ZWrite Off
        //提取的Pass
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            v2f vert(appdata_base v){
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;
                return o;
            }

            fixed4 frag(v2f i):SV_Target{
                //采样源纹理颜色
                fixed4 color = tex2D(_MainTex, i.uv);
                //得到亮度贡献值
                fixed value = clamp(luminance(color) - _LuminanceThreshold, 0, 1);
                //返回颜色*亮度贡献值
                return color * value;
            }

            ENDCG
        }

        //复用高斯模糊的2个Pass(这里需要回到高斯模糊的pass那里命名pass)
        UsePass "Unlit/GaussianBlur/GAUSSIAN_BLUR_HORIZONTAL"
        UsePass "Unlit/GaussianBlur/GAUSSIAN_BLUR_VERTICAL"

        //用于合成的Pass
        Pass
        {
            CGPROGRAM
            #pragma vertex vertBloom
            #pragma fragment fragBloom

            struct v2fBloom
            {
                float4 pos:SV_POSITION;
                //xy主要用于对主纹理进行采样
                //zw主要用于对亮度模糊后的纹理采样
                half4 uv:TEXCOORD0;
            };

            v2fBloom vertBloom(appdata_base v)
            {
                v2fBloom o;

                o.pos = UnityObjectToClipPos(v.vertex);
                //亮度纹理和主纹理 要采样相同的地方进行颜色叠加
                o.uv.xy = v.texcoord;
                o.uv.zw = v.texcoord;

                //用宏去判断uv坐标是否被翻转
                #if UNITY_UV_STARTS_AT_TOP
                //如果纹素的y小于0 为负数 表示需要对Y轴进行调整
                if(_MainTex_TexelSize.y < 0)
                    o.uv.w = 1 - o.uv.w;
                #endif

                return o;
            }

            fixed4 fragBloom(v2fBloom i):SV_TARGET
            {
                return tex2D(_MainTex, i.uv.xy) + tex2D(_Bloom, i.uv.zw);
            }

            ENDCG
        }
    }
    Fallback Off
}

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

public class Lesson108_Bloom : PostEffectBase
{
    //亮度阈值变量
    [Range(0, 4)]
    public float luminanceThreshold = 0.5f;

    [Range(1, 8)]
    public int downSample = 1;
    [Range(1, 16)]
    public int iterations = 1;
    [Range(0, 3)]
    public float blurSpread = 0.6f;

    protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if(material != null)
        {
            //设置亮度阈值变量
            material.SetFloat("_LuminanceThreshold", luminanceThreshold);

            int rtW = source.width / downSample;
            int rtH = source.height / downSample;

            //渲染纹理缓冲区
            RenderTexture buffer = RenderTexture.GetTemporary(rtW, rtH, 0);
            //采用双线性过滤模式来缩放 可以让缩放效果更平滑
            buffer.filterMode = FilterMode.Bilinear;
            //第一步 提取处理 用我们的提取Pass去得到对应的亮度信息 存入到缓冲区纹理中
            Graphics.Blit(source, buffer, material, 0);

            //第二步 模糊处理
            //多次去执行 高斯模糊逻辑
            for (int i = 0; i < iterations; i++)
            {
                //如果想要模糊半径影响模糊想过更强烈 更平滑
                //一般可以在我们的迭代中进行设置 相当于每次迭代处理高斯模糊时 都在增加我们的间隔距离
                material.SetFloat("_BlurSpread", 1 + i * blurSpread);

                //又声明一个新的缓冲区
                RenderTexture buffer1 = RenderTexture.GetTemporary(rtW, rtH, 0);

                //因为我们需要用两个Pass 处理图像两次 
                //进行第一次 水平卷积计算
                Graphics.Blit(buffer, buffer1, material, 1); //Color1
                //这时 关键内容都在buffer1中 buffer没用了 释放掉
                RenderTexture.ReleaseTemporary(buffer);

                buffer = buffer1;
                buffer1 = RenderTexture.GetTemporary(rtW, rtH, 0);
                //进行第二次 垂直卷积计算
                Graphics.Blit(buffer, buffer1, material, 2);//在Color1的基础上乘上Color2 得到最终的高斯模糊计算结果
                                                            //释放缓存区
                RenderTexture.ReleaseTemporary(buffer);
                //buffer和buffer1指向的都是这一次高斯模糊处理的结果
                buffer = buffer1;
            }
            //把提取出来的内容进行高斯模糊后 存储Shader当中的一个纹理变量
            //用于之后进行合成
            material.SetTexture("_Bloom", buffer);

            //测试 看到提取效果
            //Graphics.Blit(buffer, destination);

            //合成步骤
            Graphics.Blit(source, destination, material, 3);

            RenderTexture.ReleaseTemporary(buffer);
        }
        else
        {
            Graphics.Blit(source, destination);
        }
    }
}

Shader "Unlit/Lesson109_MotionBlur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //模糊程度变量
        _BlurAmount("BlurAmount", Float) = 0.5
    }
    SubShader
    {
        CGINCLUDE

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        fixed _BlurAmount;

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

        v2f vert (appdata_base v)
        {
            v2f o;
            o.vertex = UnityObjectToClipPos(v.vertex);
            o.uv = v.texcoord;
            return o;
        }

        ENDCG

        //屏幕后处理效果标配
        ZTest Always
        Cull Off
        ZWrite Off

        //第一个Pass 用于混合RGB通道
        Pass
        {
            //（(源颜色 * _BlurAmount) + (目标颜色 * (1 - _BlurAmount))）
            Blend SrcAlpha OneMinusSrcAlpha
            //（只改变颜色缓冲区中的RGB通道）
            ColorMask RGB

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment fragRGB
            
            fixed4 fragRGB (v2f i) : SV_Target
            {
                return fixed4(tex2D(_MainTex, i.uv).rgb, _BlurAmount);
            }
            ENDCG
        }

        Pass
        {
            //（最终颜色 = (源颜色 * 1) + (目标颜色 * 0)）
            Blend One Zero
            //（只改变颜色缓冲区中的A通道）
            ColorMask A

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment fragA
            
            fixed4 fragA (v2f i) : SV_Target
            {
                return fixed4(tex2D(_MainTex, i.uv));
            }
            ENDCG
        }
    }
    Fallback Off
}

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

public class Lesson109_MotionBlur : PostEffectBase
{
    [Range(0,0.9f)]
    public float blurAmount = 0.5f;
    //堆积纹理 用于存储之前渲染的结果的 渲染纹理
    private RenderTexture accumulationTex;

    protected override void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (material != null)
        {
            //初始化堆积纹理 如果为空 或者 屏幕宽高变化了 都需要重新初始化
            if( accumulationTex == null ||
                accumulationTex.width != source.width ||
                accumulationTex.height != source.height)
            {
                DestroyImmediate(accumulationTex);
                //初始化
                accumulationTex = new RenderTexture(source.width, source.height, 0);
                accumulationTex.hideFlags = HideFlags.HideAndDontSave;
                //保证第一次 累积纹理中也是有内容 因为之后 它的颜色 会作为颜色缓冲区中的颜色
                Graphics.Blit(source, accumulationTex);
            }
            //1 - 模糊程度的目的 是因为 希望大到的效果是 模糊程度值越大 越模糊
            //因为Shader中的混合因子的计算方式决定的 因此 我们需要1 - 它
            material.SetFloat("_BlurAmount", 1.0f - blurAmount);

            //利用我们的材质 进行混合处理
            //第二个参数 有内容时  它会作为颜色缓冲区的颜色来进行处理
            //没有直接写入目标中的目的 也是可以通过accumulationTex记录当前渲染结果
            //那么在下一次时 它就相当于是上一次的结果了
            Graphics.Blit(source, accumulationTex, material); 

            Graphics.Blit(accumulationTex, destination);
        }
        else
            Graphics.Blit(source, destination);
    }

    /// <summary>
    /// 如果脚本失活 那么把累积纹理删除掉
    /// </summary>
    private void OnDisable()
    {
        DestroyImmediate(accumulationTex);
    }
}

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

public class MotionBlur : PostEffectBase {
    [Range(0, 0.9f)] public float blurAmount = 0.5f;

    //堆积纹理 用于存储之前渲染的结果的 渲染纹理
    private RenderTexture accumulationTex;
    protected override void OnRenderImage(RenderTexture source, RenderTexture destination) {
        if (material!=null) {
            if (accumulationTex == null || accumulationTex.width!= source.width || accumulationTex.height!= source.height) {
                DestroyImmediate(accumulationTex);
               //设置DefaultHDR参数可以解决天空盒拖影问题
                accumulationTex=new RenderTexture(source.width,source.height,0,RenderTextureFormat.DefaultHDR);
                accumulationTex.hideFlags = HideFlags.HideAndDontSave;
                Graphics.Blit(source, accumulationTex);
            }
            //因为Shader中的混合因子的计算方式决定的 因此 我们需要1 - 它
            material.SetFloat("_BlurAmount", 1.0f - blurAmount);
            Graphics.Blit(source, accumulationTex, material);
            Graphics.Blit(accumulationTex, destination);  
        }
        else {
            Graphics.Blit(source, destination); 
        }
     
    }
}