Unity Shader实现运动模糊(二) : 物体运动产生模糊

上一篇 关于运动模糊的效果是根据VP矩阵重建世界空间坐标，然后根据上一帧和当前帧的位置差作为速度方向，这种方式需要摄像机有位移才能产生效果，如果摄像机静止不动，那么VP矩阵也就不会有变化，所以上一帧和当前帧在NDC空间的位置也没有变化，即speed==0，也就不会有运动模糊的效果，而想要在摄像机不动而物体移动时产生模糊效果，则需要另一种实现方式，这种方式更简洁直观。

大致思路是:

1. C#中记录运动物体的 当前帧的世界坐标 和 当前帧的VP矩阵
2. C#中记录运动物体的 上一帧的世界坐标 和 上一帧的VP矩阵
3. Shader中根据上面的信息求出 当前帧 和 上一帧的NDC坐标
4. NDC坐标求差值得出速度方向，然后沿速度方向进行多次采样后求平均值

这只是我自己的一个不成熟的实现思路，如果哪位大神有更合适的实现方式请一定赐教哈。

这种实现方式不需要对深度纹理进行采样，因此摄像机也不用设置depthTextureMode。但是按照这个思路实现出来以后发现整个画面都被模糊了，不只是运动的物体，连背后静止的plane物体也被模糊了，原因在于使用了后处理，而后处理是对整个屏幕画面进行的处理，所以想要只对运动的物体进行模糊，那么需要单独使用一个摄像机来看运动的物体，Shader中需要写两个pass，第一个pass实现运动物体的模糊，第二个pass把主摄像机的画面和模糊后的画面叠加到一起，思路如下:

1. 调用Shader的第一个pass，实现运动的物体被模糊，结果渲染到一张RenderTexture上
2. 把这张RenderTexture作为纹理参数传递给Shader
3. 把主摄像机的画面渲染到另一张RenderTexture上
4. 调用Shader的第二个pass，把主摄像机的RT渲染到最终的RT上

第二个pass中会用到第一个pass处理后的结果。

摄像机相关的操作是:

1. 把运动物体的layer设置到和静止物体不同的层，比如可以新建一个MovingObject层
2. 新建一个摄像机，用来只看运动物体，设置culling mask = MovingObject，Depth 比主摄像机小，其余参数和主摄像机一致。
3. 从主相机的culling mask中去除MovingObject层

效果图：

那么现在开始上代码，这样看起来可能更清晰些。

C# 部分：

using UnityEngine;

// 运动模糊, 物体运动产生模糊效果 //
public class MotionBlur_ObjectMove : MonoBehaviour
{
    public Transform target;
    [Range(0, 2)]
    public float BlurSize;

    private Material m_mat;
    private const string ShaderName = "MJ/PostEffect/MotionBlur_ObjectMove";
    private Vector3 m_curWorldPos;                              // 当前帧的世界空间坐标 //
    private Vector3 m_lastWorldPos;                             // 上一帧的世界空间坐标 //
    private Matrix4x4 m_curVP;                                       // 当前帧的Vp矩阵 // 
    private Matrix4x4 m_lastVP;                                      // 上一帧的Vp矩阵 // 
    private Camera m_cam;
    private Camera m_mainCam;

    void Start()
    {
        if (target == null)
        {
            enabled = false;
            return;
        }

        Shader shader = Shader.Find(ShaderName);
        if (shader == null)
        {
            enabled = false;
            return;
        }

        m_mat = new Material(shader);

        m_cam = GetComponent<Camera>();
        if (m_cam == null)
        {
            enabled = false;
            return;
        }

        m_mainCam = Camera.main;
        if (m_mainCam == null)
        {
            enabled = false;
            return;
        }
    }

    void OnRenderImage(RenderTexture srcRT, RenderTexture dstRT)
    {
        if (m_mat == null || m_cam == null || target == null)
        {
            return;
        }

        RenderTexture mainCamRT = RenderTexture.GetTemporary(srcRT.width, srcRT.height, 24);
        RenderTexture blurRT = RenderTexture.GetTemporary(srcRT.width, srcRT.height, 24);
        
        m_mainCam.targetTexture = mainCamRT;

        m_curVP = m_cam.projectionMatrix * m_cam.worldToCameraMatrix;
        m_curWorldPos = target.position;

        m_mat.SetFloat("_BlurSize", BlurSize);
        m_mat.SetVector("_CurWorldPos", m_curWorldPos);
        m_mat.SetMatrix("_CurVP", m_curVP);
        m_mat.SetVector("_LastWorldPos", m_lastWorldPos);
        m_mat.SetMatrix("_LastVP", m_lastVP);

        m_lastWorldPos = m_curWorldPos;
        m_lastVP = m_curVP;

        // 运动模糊 //
        Graphics.Blit(srcRT, blurRT, m_mat, 0);

        m_mat.SetTexture("_BlurTex", blurRT);
        // 合并画面 //
        Graphics.Blit(mainCamRT, dstRT, m_mat, 1);

        RenderTexture.ReleaseTemporary(mainCamRT);
        RenderTexture.ReleaseTemporary(blurRT);
    }
}

Shader部分：

Shader "MJ/PostEffect/MotionBlur_ObjectMove"
{
	Properties
	{
		_MainTex ("Main Texture", 2D) = "white" {}
		_BlurSize("Blur Size", Range(0, 10)) = 1
	}

	CGINCLUDE
	#include "UnityCG.cginc"
	struct appdata
	{
		float4 vertex : POSITION;
		float2 uv : TEXCOORD0;
	};

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

	sampler2D _MainTex;
	float2 _MainTex_TexelSize;
	float4 _MainTex_ST;
	
	uniform float _BlurSize;
	uniform float4 _CurWorldPos;
	uniform float4 _LastWorldPos;
	uniform float4x4 _CurVP;
	uniform float4x4 _LastVP;
	uniform sampler2D _BlurTex;				// 运动模糊后的画面 //

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

	float4 frag1 (v2f i) : SV_Target
	{
		_CurWorldPos.w = 1;
		float4 curClipPos = mul(_CurVP, _CurWorldPos);
		float3 curNDCPos = curClipPos.rgb/curClipPos.w;

		_LastWorldPos.w = 1;
		float4 lastClipPos = mul(_LastVP, _LastWorldPos);
		float3 lastNDCPos = lastClipPos.rgb/lastClipPos.w;

		float2 speed = (curNDCPos.xy - lastNDCPos.xy)*0.5;				// 转到ndc空间做速度计算 //
		float4 finalColor = float4(0,0,0,0);							// 有颜色的部分透明度大于0, 其余部分透明度等于0 //
		for(int j=0; j<4; j++)
		{
			float2 tempUV = i.uv+j*speed*_BlurSize;
			finalColor += tex2D(_MainTex, tempUV);
		}
		finalColor *= 0.25;
		return finalColor;
	}

	float4 frag2 (v2f i) : SV_Target
	{
		float4 mainTex = tex2D(_MainTex, i.uv);
		float4 blurTex = tex2D(_BlurTex, i.uv);
		float4 finalColor = float4(0,0,0,1);
		if(blurTex.a > 0)
		{
			finalColor.rgb = lerp(mainTex.rgb, blurTex.rgb, blurTex.a);
		}
		else
		{
			finalColor.rgb = mainTex.rgb;
		}
		return finalColor;
	}
	ENDCG

	SubShader
	{
		Tags { "Queue"="Geometry" "RenderType"="Opaque" "IgnoreProjector"="True" }


		Cull Off
		ZWrite Off
		ZTest Always
		
		LOD 100

		// #0 //
		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag1
			ENDCG
		}

		// #1 //
		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag2			
			ENDCG
		}
	}
	
	Fallback Off
}

package文件
提取码：j1ld