Unity Shader 屏幕后效果——摄像机运动模糊（速度映射图实现）

速度映射图主要是为了得到每个像素相对于前一帧的运动矢量，其中一种方法是使用摄像机的深度纹理来推导。

推导过程如下：

先由深度纹理逆推出NDC（归一化的设备坐标）下的顶点坐标，利用VP矩阵（视角*投影矩阵）的逆矩阵反向变换出每个像素在世界空间中的位置，

再利用世界空间下的坐标与前一帧的VP矩阵顺向变换出前一帧的NDC坐标，利用NDC下前一帧和相当帧的坐标差来确定速度的方向，

最后利用速度的方向对纹理采样的结果进行加权平均并多次绘制，以达到带有物体运动方向的模糊效果。

基于这一原理，需要准备的要素有：

1.摄像机的深度纹理（是由NDC下的坐标映射来的，需要先反向映射回NDC）

2.当前帧的VP矩阵的逆矩阵

3.前一帧的VP矩阵

摄像机深度值和深度纹理的获取方法在之前的博客中有写，具体可以参考：

https://www.cnblogs.com/koshio0219/p/11178215.html

视角矩阵（V矩阵）：

MyCamera.worldToCameraMatrix;（也就是世界空间变换到摄像机空间（也叫视角空间，观察空间））

投影矩阵（P矩阵）：

MyCamera.projectionMatrix;（也就是摄像机空间变换到裁剪空间）

具体的数学推导过程可以见这篇文章：

http://feepingcreature.github.io/math.html

下面是具体的程序实现：

1.此脚本挂载在摄像机上，用于模糊参数调控，深度纹理准备，矩阵传递：

using UnityEngine;

public class MotionBlurWithDepthTexCtrl : ScreenEffectBase
{
    private const string _BlurSize = "_BlurSize";
    private const string _PreViewMatrix = "_PreViewMatrix";
    private const string _CurViewInserseMatrix = "_CurViewInserseMatrix";

    [Range(0.0f, 1.0f)]
    public float blurSize = .5f;

    //前一帧的VP矩阵
    private Matrix4x4 preViewMatrix;

    private Camera myCamera;
    public Camera MyCamera
    {
        get
        {
            if(null == myCamera)
            {
                myCamera = GetComponent<Camera>();
            }
            return myCamera;
        }
    }

    //开启这相机深度模式，并初始化前一帧的VP矩阵
    private void OnEnable()
    {
        MyCamera.depthTextureMode |= DepthTextureMode.Depth;

        //右乘原则，前边是P矩阵，后边是V矩阵
        preViewMatrix = MyCamera.projectionMatrix * MyCamera.worldToCameraMatrix;
    }

    //不用时恢复
    private void OnDisable()
    {
        MyCamera.depthTextureMode &= ~DepthTextureMode.Depth;
    }

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (Material)
        {
            Material.SetFloat(_BlurSize, blurSize);
            //设置前一帧的VP矩阵
            Material.SetMatrix(_PreViewMatrix, preViewMatrix);
            //计算当前帧VP矩阵，右乘
            Matrix4x4 curViewMatrix = MyCamera.projectionMatrix * MyCamera.worldToCameraMatrix;
            //存起来，作为下次计算的前一帧
            preViewMatrix = curViewMatrix;
            //设置当前帧的VP矩阵的逆矩阵
            Material.SetMatrix(_CurViewInserseMatrix, curViewMatrix.inverse);

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

    }
}

基类脚本见：

https://www.cnblogs.com/koshio0219/p/11131619.html

2.Shader脚本：

Shader "MyUnlit/MotionBlurWithDepthTex"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Pass
        {
            ZTest Always Cull Off ZWrite Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            sampler2D _MainTex;
            half4 _MainTex_TexelSize;
            fixed _BlurSize;
            //声明深度纹理和对应矩阵
            sampler2D _CameraDepthTexture;
            float4x4 _PreViewMatrix;
            float4x4 _CurViewInserseMatrix;

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

            struct v2f
            {
                //这里的的uv同时存了主纹理的uv和深度纹理uv，xy为主纹理，zw为深度纹理
                half4 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv.xy =v.uv;
                o.uv.zw=v.uv;

                //主纹理外的纹理要进行平台差异化处理
                #if UNITY_UV_STARTS_AT_TOP
                if(_MainTex_TexelSize.y<0)
                    o.uv.w=1-o.uv.w;        
                #endif

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //用深度纹理和zw取得深度值
                float d=SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture,i.uv.zw);
                //反映射回NDC坐标，由[0,1]到[-1,1]的映射，z分量就是深度值本身
                float4 H=float4(i.uv.x*2-1,i.uv.y*2-1,d*2-1,1);
                //用VP的逆矩阵反向变换并除以w分量得到世界坐标位置，为什么除以w详细见前面数学推导的文章链接
                float4 D=mul(_CurViewInserseMatrix,H);
                float4 worldPos=D/D.w;

                //分别得到前一帧和当前帧的NDC坐标取差值计算速度方向
                float4 curViewPos=H;
                float4 preViewPos=mul(_PreViewMatrix,worldPos);
                preViewPos/=preViewPos.w;

                //除以的系数可以根据自己的需求调整
                float2 velocity=(curViewPos.xy-preViewPos.xy)/10.0f;

                float2 uv=i.uv.xy;
                //纹理采样的速度权重，这里进行了前2帧的计算，包括当前帧总共3个值，值依次递减且保证和为1，不为1则需要进行额外的除法
                //目的是为了让越之前的帧看上去效果越淡，轨迹逐渐消失
                float velColRate[3]={0.6,0.3,0.1};
                //当前采样结果用权重最大的值0.6
                fixed4 col = tex2D(_MainTex, uv)*velColRate[0];
                uv+=velocity*_BlurSize;

                for(int it=1;it<3;it++)
                {
                    //前两帧采样结果依次递减，0.3,0.1
                    fixed4 curCol=tex2D(_MainTex,uv.xy)*velColRate[it];
                    //将所有结果加起来，保证权重为1
                    col+=curCol;
                    //按速度方便对纹理进行偏移，并用模糊系数加以控制
                    uv+=velocity*_BlurSize;
                }

                return fixed4(col.rgb,1.0);
            }
            ENDCG
        }
    }
    FallBack Off
}

效果如下：